Java并发和多线程4：使用通用同步工具CountDownLatch实现线程等待

CountDownLatch，一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。
之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。
这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用 CyclicBarrier。

CountDownLatch 是一个通用同步工具，它有很多用途。
将计数 1 初始化的 CountDownLatch 用作一个简单的开/关锁存器，或入口：在通过调用 countDown() 的线程打开入口前，所有调用 await的线程都一直在入口处等待。
用 N 初始化的 CountDownLatch 可以使一个线程在 N 个线程完成某项操作之前一直等待，或者使其在某项操作完成 N 次之前一直等待。

CountDownLatch 的一个有用特性是，它不要求调用 countDown 方法的线程等到计数到达零时才继续，而在所有线程都能通过之前，它只是阻止任何线程继续通过一个 await。

用法1： 下面给出了两个类，其中一组 worker 线程使用了两个倒计数锁存器： 
// 第一个类是一个启动信号，在 driver 为继续执行 worker 做好准备之前，它会阻止所有的 worker 继续执行。
// 第二个类是一个完成信号，它允许 driver 在完成所有 worker 之前一直等待。

class Driver {
	void start() throws InterruptedException {
		CountDownLatch startSignal = new CountDownLatch(1);
		int N = 5;
		CountDownLatch doneSignal = new CountDownLatch(N);

		for (int i = 0; i < N; i++) {
			Worker worker = new Worker(startSignal, doneSignal,i);
			Thread thread = new Thread(worker);
			thread.start();
		}

		doSomethingElse(1); // 所有线程都还没有开始执行
		startSignal.countDown(); // 让所有线程开始执行
		doSomethingElse(2);
		doneSignal.await(); // 等待所有线程结束
		doSomethingElse(3);
	}

	// 执行一些其它的事情，具体结合实际情况
	private void doSomethingElse(int i) {
		System.out.println("doSomethingElse-"+i);
	}
}

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

	public void run() {
		try {
			startSignal.await();
			doWork(i);
			doneSignal.countDown();
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		}
	}

	void doWork(int i) {
		System.out.println("doWork-"+i);
	}
}

// 另一种典型用法2，将一个问题分成 N 个部分，用执行每个部分并让锁存器倒计数的 Runnable 来描述每个部分，然后将所有 Runnable
// 加入到 Executor 队列。当所有的子部分完成后，协调线程就能够通过
// await。（当线程必须用这种方法反复倒计数时，可改为使用CyclicBarrier。）

class Driver2 {
	void start() throws InterruptedException {
		int N = 5;
		CountDownLatch doneSignal = new CountDownLatch(N);
		ExecutorService e = Executors.newFixedThreadPool(3);
		// 创建并执行线程
		for (int i = 0; i < N; ++i) {
			WorkerRunnable workerRunnable = new WorkerRunnable(doneSignal, i);
			e.execute(workerRunnable);
		}
		// 等待所有线程结束
		doneSignal.await();
		//手动关闭，才会停止所有线程
		e.shutdown();
	}
}

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-" + i);
	}
}

运行程序

package cn.fansunion.executorframework;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchDemo {

	public static void main(String[] args) throws InterruptedException {
		//Driver中的若干Thread，执行完毕后，自动就关闭了
		Driver driver = new Driver();
		driver.start();
		//Driver2中，需要手动调用ExecutorService.shutdown关闭线程
		Driver2 driver2 = new Driver2();
		driver2.start();
	}

}

控制台结果
doSomethingElse-1
doSomethingElse-2
doWork-0
doWork-2
doWork-4
doWork-3
doWork-1
doSomethingElse-3
doWork-1
doWork-0
doWork-3
doWork-4
doWork-2

更多代码示例：
http://git.oschina.net/fansunion/Concurrent（逐步更新中）

参考资料：

有条件地终止 ScheduledExecutorService 中运行的定时任务
http://www.oschina.net/question/1158769_119659?sort=time

JDK API 文档