CountDownLatch 2

 

 

package com.ls.java_concurrency.countdownlatch;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Another typical usage would be to divide a problem into N parts,
 * describe each part with a Runnable that executes that portion and
 * counts down on the latch, and queue all the Runnables to an
 * Executor.  When all sub-parts are complete, the coordinating thread
 * will be able to pass through await. (When threads must repeatedly
 * count down in this way, instead use a CyclicBarrier.)
 * @author astute_sparrow
 * ------Driver------
 */
public class CountDownLatchAnotherDemo {
	
	public static void main(String[] args) throws InterruptedException {
		CountDownLatch doneSignal = new CountDownLatch(10);
		final BlockingQueue<Runnable> queue = new SynchronousQueue<Runnable>();
		final ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 600, 30,
				TimeUnit.SECONDS, queue, Executors.defaultThreadFactory(),
				new ThreadPoolExecutor.AbortPolicy());
		for(int i=0; i<20; i++)
			executor.execute(new WorkerRunnable(doneSignal, 1));
		System.out.println("Main Thread starts......");
		Thread.sleep(10000);
		doneSignal.await();
		System.out.println("All sub thread ends!!!");
	}
	
}

class WorkerRunnable implements Runnable {
	private final CountDownLatch doneSignal;
	private final int i;
	WorkerRunnable(CountDownLatch doneSignal, int i) {
		this.doneSignal = doneSignal;
		this.i = i;
	}

	public void run() {
		doWork(i);
		doneSignal.countDown();
	}
	
	void doWork(int i) {
		System.out.println("......doWork......" + Thread.currentThread());
	}
}