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();
            }
        }
 
    }
}
  

    
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");