用给定的计数 初始化 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 文档