How to execute a piece of code only after all threads are done

Question

I have a logging code which needs to be executed after all Threadss are executed.

Thread t1 = new MyThread();
Thread t2 = new MyThread();
t1.run();
t2.run();

doLogging();

Is there any way to execute doLogging() only after both threads are done with their processing. Now that doLogging() is called as soon as t1 and t2 are started.

Ochs

It should be pointed out that since you are calling run instead of start you're already getting the desired behavior. – Albertype

Answer 1

Just join() all threads before your doLogging() call:

t1.join();
t2.join();

// the following line will be executed when both threads are done
doLogging();

Note that the order of join() calls doesn't matter if you want to wait for all of your threads.

Roesch

Note that if you're using Java 1.5 or later the new java.util.concurrent should be preferred over low-level thread programming (see Gregory Mostizky's answer). – Changteh

@Jim: with Java 1.5 or later I wouldn't even use a CountDownLatch for such a thing, but a simple Executor. – Roesch

Answer 2

In addition to the join() solution there is also something called CountDownLatch in the java.util.concurrent library. It allows you to initialize it to a certain number and then wait until it was hit the specified number of times.

Simple example:

CountDownLatch latch = new CountDownLatch(NUMBER_OF_THREADS);
for(int i=0; i<NUMBER_OF_THREADS;i++)
   new Thread(myCode).start();

latch.await();

The latch must be explicitly hit by the worker threads for this to work though:

latch.countDown()

Briton

+1 for java.util.concurrent. This new feature makes most low-level thread programming in Java unnecessary. – Changteh

Answer 3

If you create threads using a thread pool, then you may use awaitTermination(long timeout, TimeUnit unit) method. Once time up, it will return true if all threads are finished, otherwise return false.

if(awaitTermination(timeout, unit)){
    //write your code here
}

However, since you need to estimate a timeout first, it's not as flexible as CountDownLatch. This method is usually used together with shutdown() to double-check if all threads are shut down successfully given a waiting time.

Yorick