Question

I have a java application where the main-thread starts 2 other threads.
If one of these threads terminates, the main-thread may start another thread depending on the result of the terminated thread.

Example:
The main-thread creates 2 threads: A and B. Thread A will load a picture and thread B will load another picture. If A terminates and loaded the picture successfully a new Thread C will be created which does some other stuff and so on.

How can i do this? I do not want to use busy waiting in the main thread and check every 100ms if one of the two threads has finished.
I think i cannot use a thread pool because the number of active threads (in this case A and B) will vary extremely and it’s the main-threads dicision to create a new thread or not.

This is rough sketch of the “busy waiting” solution:

public class TestThreads {
 private class MyThread extends Thread {
  volatile boolean done = false;
  int steps;

  @Override
  public void run() {
   for (int i=0; i<steps; i++) {
    System.out.println(Thread.currentThread().getName() + ": " + i);
    try {
     Thread.sleep(1000);
    } catch (InterruptedException exc) {  }
   }
   done = true;
   synchronized (this) {
    notify();
   }
  }

  public void waitFor(long ms) {
   synchronized (this) {
    try {
     wait(ms);
    } catch (InterruptedException exc) {  }    
   }
  }
 }

 public void startTest() {
  MyThread a = new MyThread();
  a.steps = 6;
  a.start();

  MyThread b = new MyThread();
  b.steps = 3;
  b.start();

  while (true) {
   if (!a.done) {
    a.waitFor(100);
    if (a.done) {
     System.out.println("C will be started, because A is done.");
    }
   }

   if (!b.done) {
    b.waitFor(100);
    if (b.done) {
     System.out.println("C will be started, because B is done.");
    }
   }

   if (a.done && b.done) {
    break;
   }
  }
 }

 public static void main(String[] args) {
  TestThreads test = new TestThreads();
  test.startTest();
 }
}

Answer 1

This sounds like a classic case for using a ThreadPoolExecutor for performing the tasks concurrently, and wrapping it with an ExecutorCompletionService, for collecting the results as they arrive.

For example, assuming that tasks contains a set of tasks to execute in parallel, each returning a String value when it terminates, the code to process the results as they become available can be something like:

List<Callable<String>> tasks = ....;
Executor ex = Executors.newFixedThreadPool(10);
ExecutorCompletionService<String> ecs = new ExecutorCompletionService<String>(ex);
for (Callable<String> task : tasks) 
    ecs.submit(task);
for(int i = 0; i < tasks.size(); i++) {
    String result = ecs.take().get();
    //Do something with result
}

If you include the identity of the task as a part of the returned value, then you can make decisions depending on the completion order.