在java中的线程之间来回发送对象？

Question

I have multiple client handler threads, these threads need to pass received object to a server queue and the sever queue will pass another type of object back to the sending thread. The server queue is started and keeps running when the server starts.I am not sure which thread mechanism to use for the client handler threads notified an object is sent back. I don't intend to use socket or writing to a file.

Answer 1

If you wanted to do actual message passing take a look at SynchronusQueue . Each thread will have reference to the queue and would wait until one thread passed the reference through the queue.

This would be thread safe and address your requirements.

Though if you are simply looking to have threads read and write a shared variable you can use normalocity's suggestion though it's thread-safety depends on how you access it (via sychronized or volatile)

Answer 2

As far as making objects accessible in Java, there's no difference between multi-thread and single-thread. You just follow the scope rules (public, private, protected), and that's it. Multiple threads all run within the same process, so there isn't any special thread-only scope rules to know about.

For example, define a method where you pass the object in, and make that method accessible from the other thread. The object you want to pass around simply needs to be accessible from the other thread's scope.

As far as thread-safety, you can synchronize your writes , and for the most part, that will take care of things. Thread safety can get a bit hairy the more complicated your code, but I think this will get you started.

One method for processing objects, and producing result objects is to have a shared array or LinkedList that acts as a queue of objects, containing the objects to be processed, and the resulting objects from that processing. It's hard to go into much more detail than that without more specifics on what exactly you're trying to do, but most shared access to objects between threads comes down to either inter-thread method calls, or some shared collection/queue of objects.

Answer 3

Unless you are absolutely certain that it will always be only a single object at a time, use some sort of Queue.

If you are certain that it will always be only a single object at a time, use some sort of Queue anyway. :-)

Answer 4

Just use simple dependency injection .

MyFirstThread extends Thread{
 public void setData(Object o){...}
}
MySecondThread extends Thread{
   MyFirstThread callback;
   MySecondThread(MyFirstThread callback){this.callback=callback)
}
MyFirstThread t1 = new MyFirstThread();
MySecondThread t2 = new MySecondThread(t1);    
t1.start();
t2.start();

You can now do callback.setData(...) in your second thread.

I find this to be the safest way. Other solutions involve using volatile or some kind of shared object which I think is an overkill.

You may also want to use BlockingQueue and pass both of those to each thread. If you plan to have more than one thread then it is probably a better solution.

Answer 5

• Use a concurrent queue from the java.util.concurrent.*.

why? Almost guaranteed to provide better general performance than any thing hand rolled.

recommendation: use a bound queue and you will get back-pressure for free.

note: the depth of queue determines your general latency characteristics: shallower queues will have lower latencies at the cost of reduced bandwidth.

• Use Future semantics

why? Futures provide a proven and standard means of getting asynchronous result.

recommendation: create a simple Request class and expose a method #getFutureResponse(). The implementation of this method can use a variety of signaling strategies, such as Lock, flag (using Atomic/CAS), etc.

note: use of timeout semantics in Future will allow you to link server behavior to your server SLA eg #getFutureResponse(sla_timeout_ms).

Answer 6

如果您想更深入地了解线程（或进程或系统）之间的通信，可以获得一本书的小贴士： 面向模式的软件架构第2卷：并发和联网对象的模式