Parent Thread should wait till all child thread are dead

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 ]

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 ]

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).

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

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!

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.

Point well taken. Tx for the comment

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

Thanks All !!

It solved my problem too.