Java多线程通信

Question

I'm relatively new using Java multi-threading and concurrence tools . I'm implementing an app which has an event producer (let's call it EventProducer ). EventProducer has a thread pool FixedThreadPool , where one new thread per event to process is sent, submiting a new EventProcessor thread to the pool.

That's going all right, a thread in the pool is being created per event arrived. But problem is that I want to communicate that EventProcessor thread (which is specific for each event request) with two threads that are supposed to be application scoped, I mean, I'll have only an instance of them in the application, let's say Service1 and Service2 . Both of them have thread pools, to be able to process the tasks concurrently.

That specific EventProcessor sends sets of tasks to Service1 and it returns responses for each task. For that responses, I have looked for CompletionService but I don't know how can I integrate it with Blocking queues for bi-directional communication. After, depending on that response, EventProcessor sends one action or another to execute in Service2 . Service2 will also send a response about that action to EventProcessor .

Anybody knows about how can I tackle such problem? I need an introduction in order to achieve the first steps. Pool your ideas.

Answer 1

The best object for inter-thread communications is the BlockingQueue . They are super-flexible and thread safe and will usually handle all requirements.

BlockingQueue<Task> queue = new LinkedBlockingQueue<>();

Answer 2

Let you Service1 and 2 be ExecutorService s. Your EventProcessor sends tasks in the form of Callables to Service1, using a return type R that encapsulates your response. It also queues up the resulting Futures. In another thread, you receive those responses and dispatch new callables to Service2. You can also use a CompletionService for that.

Answer 3

What if you have a non-blocking queue in your event dispatcher thread, such as the ConcurrentLinkedQueue . You then pass a reference to that into your Callable so it can add responses to the queue.
In your event dispatcher you could then periodically poll the queue to see if it has anything interesting in it. As the queue is non blocking it would just return null when it's empty.

Answer 4

Finally I managed to solve it in the following way: EventProducer creates services Service1 and Service2 , which are runnable objects, and launches them as threads. Each of these service keeps waitting for result on its pool, which is implemented as CompletionService . Those service reference is keeped in EventProducer and passed by reference to every EventProcessor , which is created when an event is launched.

EventProcessor has two BlockingQueue elements, each of them is used to receive responses from the services. When I want to call a service, I do it trough the object's reference and call the dispatch method of the service, passing a collection of elements I want to process as parameter and also the reference of EventProcessor itself. The call is done following the thread of EventProcessor , but it only creates a callable object per object to process, executing code into the service class, which submits the new threads to his pool.

When the result is given, the service, which is waiting for it in his own thread, puts it into the BlockingQueue of the EventProcessor , because it has his reference. After EventProcessor manages the results into his own thread (and can send other actions to other services).

That's all, many thanks for people helping, you've your upvotes because every answer has clarified me some concept.