Dependent threads in Executor Service - Java

Question

I am dealing with multiple threads in my program. There are some independent threads and some threads depend on the completion of some other thread before it starts execution.

Currently I'm doing this

for ( final String inElementId : inElements ) 
{
    Thread thread = threadsMap.get( inElementId );
    if ( ( thread != null ) && thread.interrupted() ) 
    {
        Thread.currentThread().interrupt();
        throw new RuntimeException();
    } else {
        thread.join();
    }
}

So each threads checks if the thread on which it depends is still running then it waits for its completion.

I want to write an executor service to manage threads in a systematic way. But I couldn't find a way where I can check the dependencies.

How can I do this using a thread pool executor service that thread B should only be submitted once thread A has completed execution ? Or is there any other better way to manage such threads?

P.S: It is also possible that thread B is submitted first, but it depends on A so it keeps on waiting until thread A is submitted and it completes execution.

Answer 1

You can use CountDownLatch.

Lets say you have thread "A" that depends on thread "B".

You need to create a CountDownLatch object initialize to value 1(If thread A depends on only one thread).

In thread B pass the latch object and once you complete the execution of method(method called by thread B) at the end you can keep latch.countDown(), which will count down the latch by 1.

Same latch object you will pass to thread A also. But There you will be keeping latch.await() as first line, which means your thread A will wait till latch count becomes 0.

So, when you thread B completes it will count down the latch and make latch count to 0. Which will trigger subsequent line in thread A, after latch.await() line. Basically, it will trigger thread A.

Read About Count Down latch here: http://howtodoinjava.com/core-java/multi-threading/when-to-use-countdownlatch-java-concurrency-example-tutorial/

Answer 2

You can also achieve the same thing using callable. It returns the Future instance and with that you can verify if task has been completed or not.

Future future = executorService.submit(new Callable(){
public Object call() throws Exception {
    System.out.println("Asynchronous Callable");
    return "Callable Result";
}});

Add this future instance reference in your threads as dependency, before execution they will refer if future task is executed or not.

if (future.isDone()){
  //do something
}

You can refer to this example - http://javahash.com/java-concurrency-future-callable-executor-example/