CountDownLatch是一个同步工具类，用来协调多个线程之间的同步。
CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。当每一个线程完成自己任务后，计数器的值就会减一。当计数器的值为0时，表示所有的线程都已经完成一些任务，然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务。
举个例子来说明CountDownLatch的使用：
百米赛跑，10名运动员选手到达场地等待裁判口令，裁判一声口令，选手听到后同时起跑，当所有选手到达终点，裁判进行汇总排名。
public class CountDownLatchTest {
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
final CountDownLatch cdOrder = new CountDownLatch(1);
final CountDownLatch cdAnswer = new CountDownLatch(10);
for(int i=0; i<10; i++){
Runnable runnable = new Runnable() {
@Override
public void run() {
try{
System.out.println("选手" + Thread.currentThread().getName() + "正在等待裁判发布口令");
cdOrder.await();
System.out.println("选手" + Thread.currentThread().getName() + "已接受裁判口令");
Thread.sleep((long) (Math.random() * 10000));
System.out.println("选手" + Thread.currentThread().getName() + "到达终点");
cdAnswer.countDown();
}catch (InterruptedException ie){
ie.printStackTrace();
}
}
};
service.execute(runnable);
}
try {
Thread.sleep((long) (Math.random() * 10000));
System.out.println("裁判"+Thread.currentThread().getName()+"即将发布口令");
cdOrder.countDown();
System.out.println("裁判"+Thread.currentThread().getName()+"已发送口令，正在等待所有选手到达终点");
cdAnswer.await();
System.out.println("所有选手都到达终点");
System.out.println("裁判"+Thread.currentThread().getName()+"汇总成绩排名");
} catch (InterruptedException e) {
e.printStackTrace();
}
service.shutdown();
}
}
运行结果如下：
选手pool-1-thread-1正在等待裁判发布口令
选手pool-1-thread-3正在等待裁判发布口令
选手pool-1-thread-2正在等待裁判发布口令
选手pool-1-thread-4正在等待裁判发布口令
选手pool-1-thread-5正在等待裁判发布口令
选手pool-1-thread-6正在等待裁判发布口令
选手pool-1-thread-7正在等待裁判发布口令
选手pool-1-thread-8正在等待裁判发布口令
选手pool-1-thread-9正在等待裁判发布口令
选手pool-1-thread-10正在等待裁判发布口令
裁判main即将发布口令
裁判main已发送口令，正在等待所有选手到达终点
选手pool-1-thread-3已接受裁判口令
选手pool-1-thread-2已接受裁判口令
选手pool-1-thread-1已接受裁判口令
选手pool-1-thread-9已接受裁判口令
选手pool-1-thread-8已接受裁判口令
选手pool-1-thread-7已接受裁判口令
选手pool-1-thread-6已接受裁判口令
选手pool-1-thread-5已接受裁判口令
选手pool-1-thread-4已接受裁判口令
选手pool-1-thread-10已接受裁判口令
选手pool-1-thread-7到达终点
选手pool-1-thread-3到达终点
选手pool-1-thread-10到达终点
选手pool-1-thread-9到达终点
选手pool-1-thread-1到达终点
选手pool-1-thread-5到达终点
选手pool-1-thread-4到达终点
选手pool-1-thread-2到达终点
选手pool-1-thread-8到达终点
选手pool-1-thread-6到达终点
所有选手都到达终点
裁判main汇总成绩排名
具体看一下CountDownLatch是如何实现线程调度的。
首先看一下其构造方法：
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
继续看一下Sync。
// Sync继承自AQS
private static final class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 4982264981922014374L;
Sync(int count) {
setState(count);
}
int getCount() {
return getState();
}
// 定义尝试获取共享锁的方法
protected int tryAcquireShared(int acquires) {
// 当状态为0，则该线程获取到该共享锁
return (getState() == 0) ? 1 : -1;
}
protected boolean tryReleaseShared(int releases) {
// 减少count，当检测到状态值为0时，通知同步队列中被挂起的线程
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
}
可以发现，CountDownLatch是基于AQS共享锁来实现的，,只要共享锁状态值不为0，则请求共享锁的线程均会添加到同步队列中，阻塞挂起，等待被通知。
接着看一下await方法：
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
直接调用的是AQS的acquireSharedInterruptibly方法：
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
// tryAcquireShared由Sync实现，即只要状态不为0，则返回-1
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
CountDownLatch初始化后状态值肯定不为0，所以当前线程tryAcquireShared必然返回-1，继续执行doAcquireSharedInterruptibly方法。
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
// 将当前线程添加到同步队列
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
// 若当前线程所在节点的前继节点为头节点，则执行tryAcquireShared尝试获取共享锁
if (p == head) {
// 因为状态值不为0，tryAcquireShared必然返回-1
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
// 将前继节点状态CAS更改为SIGNAL后，然后线程阻塞挂起
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
综上，持有CountDownLatch的线程只要调用await方法，就会被添加进AQS的同步队列，并被阻塞挂起。
那这些被阻塞挂起的线程啥时候会被唤醒继续执行呢？
答案在CountDownLatch的countDown方法中：
public void countDown() {
sync.releaseShared(1);
}
底层调用的是AQS的releaseShared方法:
public final boolean releaseShared(int arg) {
// 若状态执行-1操作后，状态值未归零，tryReleaseShared返回false
// 若状态执行-1操作后，状态值归零，tryReleaseShared返回true
if (tryReleaseShared(arg)) {
// 若状态值归零，继续执行doReleaseShared方法
doReleaseShared();
return true;
}
return false;
}
当状态值归零后，当前线程会执行AQS的doReleaseShared方法，doReleaseShared方法我们在之前AQS详解的系列文章里详细介绍过，该方法是一个"唤醒风暴"，其会唤醒同步队列中阻塞挂起的线程。
唤醒后的线程会进行获取锁的操作，当状态值归零后，由于tryReleaseShared恒返回1，代表任何线程均可以获取共享锁成功，当线程获取到锁之后，会执行setHeadAndPropagate方法将当前节点置为头节点并唤醒后继节点，后继节点被唤醒后执行获取锁操作，如此反复，直到同步队列中的所有阻塞线程被唤醒。
需要注意的是：CountDownLatch是一次性的，计算器的值只能在构造方法中初始化一次，之后没有任何机制再次对其设置值，当CountDownLatch使用完毕后，它不能再次被使用。