Parent Thread should wait till all child thread are dead

[Purujit Saha]

I have a Parent Class which spawns 10 child threads,

class Parent{

public static void main(String[] args) {

int threadWorkerNo = 10;
processStartTime = System.currentTimeMillis();
spawnThreads(threadWorkerNo);

System.out.println("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");

}

private static void spawnThreads(int number){

for(int i=1;i<=number; i++){
String name = Integer.toString(i);
MigrationWorker th = new MigrationWorker(name);
th.startThread();
}

}
}

Assume the MigrationWorker is a Thread Class which does some work.
now i want the Parent class main method to wait till all the 10 migration workers thread are died.
That means when all the 10 child threads are dead,&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& will be printed.

Thanks in advance....

[ April 09, 2007: Message edited by: Purujit Saha ]
[ April 09, 2007: Message edited by: Purujit Saha ]

[Nitesh Kant]

You can use the following code to do the needful.

  package test;
 
import java.util.concurrent.atomic.AtomicInteger;
 
public class DeathBed {
 
    public static void main(String[] args) {
        Object monitor = new Object();
        Cremator cremator = new Cremator(10, monitor);
        for(int i=0; i < 10; i++) {
            MyThread myThread = new MyThread(cremator);
            myThread.start();
        }
        synchronized(monitor) {
            try {
                monitor.wait();
                System.out.println("Time for cremation !!!!!!!");
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
 
    private static class Cremator {
 
        private AtomicInteger deadThreads;
        private int maxThreads;
        private Object monitor;
 
        public Cremator(int maxThreads, Object monitor) {
            this.maxThreads = maxThreads;
            this.monitor = monitor;
            deadThreads = new AtomicInteger();
        }
 
        public void increment() {
            int i = deadThreads.incrementAndGet();
            System.out.println("Number of dead threads: " + i);
            if(i >= maxThreads) {
                synchronized(monitor) {
                    monitor.notifyAll();
                }
            }
        }
    }
 
    private static class MyThread extends Thread {
        private Cremator cremator;
 
        public MyThread(Cremator cremator) {
            this.cremator = cremator;
        }
 
        public void run() {
            double v = Math.random();
            try {
                Thread.sleep((long) (v * 10 * 1000));
                cremator.increment();
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
        }
 
    }
}
  

P.S: MyThread is just a dummy Implementation. It will be replaced by the actual thread that does the work you want to do.
[ April 09, 2007: Message edited by: Nitesh Kant ]

[Chris Beckey]

If you have JDK 1.5 or later then this should also work. There are also ways to do this with queued executor services (using Futures) if you want real thread pool management (please note the comments concerning queued executor services).

    
public static void main(String[] argv)
{
MigrationWorker[] tasks = getMigrationWorkers();

// The ExecutorService must immediately begin execution of the tasks,
// TASKS MUST NOT BE QUEUED !!
ExecutorService executor = Executors.newCachedThreadPool();

// submit all tasks to be executed
for(MigrationWorker task: tasks)
executor.submit(task);

// immediately shutdown the executor, this will NOT shutdown the executor threads
// but it will prevent execution of worker tasks that have not started. hence the
// requirement that the executor service immediately execute rather than queue tasks
// for later execution
executor.shutdown();
try
{
// wait for the running tasks to complete
executor.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
} 
catch (InterruptedException x)
{
// if this occurs then its probably best to just loop and await some more
x.printStackTrace();
}
}
System.out.println("This should always print last");

 

[Henry Wong]

Your spawnThreads() method doesn't save any of the thread objects for the threads that it created. If it did (such as saving the objects in a collection which is returned from the method), you can later have your main thread call join() on all the thread objects, to wait for them all to complete.

Henry

[Nitesh Kant]

Originally posted by Henry Wong:
Your spawnThreads() method doesn't save any of the thread objects for the threads that it created. If it did (such as saving the objects in a collection which is returned from the method), you can later have your main thread call join() on all the thread objects, to wait for them all to complete.

Henry

Henry, firstly i am delighted to communicate with the author of the book i learned Threads from !!!
Keeping aside the requirement in this problem, is it a good idea to use a wait-notify mechanism against the join paradigm?
One scenario can be when threads are not computation intensive and finish their work pretty soon. So, will it be more effecient to use a wait-notify mechanism over "joining". The reason being that the parent will unnecessarily try to join even if the worker thread has already finished its job?
Worth mentioning, its just a hypothetical situation for academic reasons!

[Ernest Friedman-Hill]

join() is, in fact, implemented in Java code using wait() and notify(). The first example is just a terribly complex way of implementing Henry's suggestion by hand. If I saw code like that in a review, I'd make the author change it to use join() in a loop.

[Nitesh Kant]

Point well taken. Tx for the comment

[Purujit Saha]

All of your inputs has helped me to solve my problem.
Thanks to all.

[Shiaber Shaam]

Thanks All !!

It solved my problem too.