小编Sun*_*pta的帖子

我试图编写一个Producer Consumer模型(java中的Producer线程和Consumer Thread)

我想知道如何处理方法和类的方法InterruptedException引发的Thread.sleepObjectwait()

package producerconsumer;

import java.util.ArrayList;

public class Consumer implements Runnable {

    ArrayList<Integer> container;

    @Override
    public void run() {
        while(true){
        System.out.println("Consumer Thread Running");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if(null==container){
            System.out.println("container is null");
        }
        //Removing values from Arraylist
        synchronized (container) {
            if(container.size()==0){
                try {
                    container.wait();
                } catch (InterruptedException e) {
                    //How to tackle this exception
                    e.printStackTrace();
                }
            }
            Integer removedInteger = container.remove(container.size()-1);
            System.out.println("removedInteger..."+removedInteger);
        }
        }
    }

    public void setContainer(ArrayList<Integer> …

我在互联网上阅读的Java EE和Java SE类加载的区别在于

在Java SE中,类加载器将类加载委托给其父类加载器,然后尝试加载类本身

但是,在Java EE中,类加载器首先尝试加载类本身,然后将该类的类加载委托给其父类加载器.

请证实我的理解.

另外,为什么它的设计与Java EE中的设计相同(保持这种优势的任何优点.)

这是我听到的链接[http://www.youtube.com/watch?v=t8sQw3pGJzM]

在下面的行中:

这是获取类加载器的两种方法

1)Thread.currentThread().getContextClassLoader();

2)getClass().getClassLoader();

有人请解释一下这两者之间的区别.

另外我的第二个问题是我们何时使用Thread.currentThread().getContextClassLoader()

我已经在StackOverflow上提到了一些相同的帖子,但没有找到根本的答案.

我已经看到了你提出的问题的答案.

线程的上下文类加载器和普通的类加载器之间的区别

Thread context classloaders provide a back door around the classloading delegation scheme. Take JNDI for instance: its guts are implemented by bootstrap classes in rt.jar (starting with J2SE 1.3), but these core JNDI classes may load JNDI providers implemented by independent vendors and potentially deployed in the application's -classpath. This scenario calls for a parent classloader (the primordial one in this case) to load a class visible to one of its …

在查看java代码时，我发现抽象类的构造函数被设置为受保护的。

public abstract class A {
   protected A() {

   }
}

什么

抽象对我来说意味着你不能创建此类的实例并在扩展后使用此类

。

受保护的构造函数也确保了这一点。

做两件事有什么意义，一是使构造函数受保护，二是使类抽象以解决相同的目的。

String str = new String("Hello");

通常我在互联网上的许多文章中都读到,当我们编写上述语句时,会创建两个对象.在堆上创建一个String对象,并在Literal Pool上创建一个字符串对象.并且堆对象也引用在Literal Pool上创建的对象.(如果错误,请更正我的陈述.)

请注意,上面的解释是根据我的理解,阅读了一些互联网上的文章.

所以我的问题是..是否有任何方法可以停止在文字池中创建字符串对象.怎么做？

[请告诉我有关理解此文字池的最佳链接,如何实施]

在我的应用程序中,我使用Java.Util.Logging编写了自己的Logging实用程序

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.SimpleFormatter;



public class Logger {

    public final static String PROPERTIES_FILE = "Logger.properties";
    private static java.util.logging.Logger logger = null;

    private static void initialize() {
        try {
            logger = java.util.logging.Logger.getLogger(Logger.class.getName());
            FileHandler fh = new FileHandler("D:\\MyLogFile.log", true);
            logger.addHandler(fh);
            logger.setLevel(Level.ALL);
            SimpleFormatter formatter = new SimpleFormatter();
            fh.setFormatter(formatter);
            logger.log(Level.INFO, "Test Message Logged");

        }
        catch (IOException e) {
          System.out.println("Warning: Unable to read properties file " +
                             PROPERTIES_FILE );
        }   
      }

    public static synchronized java.util.logging.Logger getLogger(String …

<td id="hello"> OPD </td>

在我的html页面上,这就是我在tr中获取td标签的方式.

我想在java脚本变量中获取值"OPD".

var td1 = document.getElementById("hello");

我可以通过对td1执行任何操作来获得此值.

有没有其他方法可以做到这一点.请帮忙

当我读到"在多少方面我们可以在java中创建一个对象"时.

我找到了四种方式:

1. 使用新操作符创建对象.
2. 克隆
3. 序列化
4. 反射.

有了新的和反思,我对这两种方法很好.

我的问题是:

为什么人们将克隆和序列化视为创建对象的不同方式？

请看下面的代码:

A级

package generalscenarios;

public class A implements Runnable{

    public void run(){

        System.out.println("dsad");

    }

}

B级

package generalscenarios;


public class B {


    public static void main(String[] args) throws InterruptedException {

        A a1  = new A();
        Thread a = new Thread(a1);
        a.start();
        System.out.println("hi");
    }
}

当我执行B类时,我的线程a将由主线程启动,并且hi将由主线程打印在控制台上.但是没有确定打印"hi"和"dsad"的顺序.

我想在"dsad"之后打印"hi".

我想到的解决方案是在主线程和线程"a"之间采用共享变量.主线程将等待该变量,直到线程"a"通知他.

A级

package generalscenarios;

public class A implements Runnable{

    public void run(){

        System.out.println("dsad");
        synchronized (this) {
            this.notify();  
        }


    }

}

B级

package generalscenarios;


public class B {


    public static void main(String[] args) throws InterruptedException …

我编写了一个Restful Web服务API,它接受两个不同的Object,是否可以使用Jersey客户端调用此api.我无法使用Jersey客户端调用此方法.这是Rest API的限制,我们无法将多个对象传递给方法.

import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

@Path("/hello")
public class TimePassService {

    @POST
    @Path("/post")
    @Consumes(MediaType.APPLICATION_JSON)
    public Response saveEmployeeInfo(final Employee input,final Manager input1) {
        String result = "Employee saved : " + input;

        System.out.println(input);
        System.out.println(input1);
        return Response.status(201).entity(result).build();
    }

}

当我与一些技术人员讨论这个时,他们回答说这是不可能的,解决方案是将这两个对象包装成第三个对象,然后传递一个Object.

如果有其他解决方案,请告诉我.