正文
若文中代码格式阅读困难，可点击文末"阅读原文"链接友好阅读。
要点解说
CountDownLatch允许一个或者多个线程一直等待，直到一组其它操作执行完成。在使用CountDownLatch时，需要指定一个整数值，此值是线程将要等待的操作数。当某个线程为了要执行这些操作而等待时，需要调用await方法。await方法让线程进入休眠状态直到所有等待的操作完成为止。当等待的某个操作执行完成，它使用countDown方法来减少CountDownLatch类的内部计数器。当内部计数器递减为0时，CountDownLatch会唤醒所有调用await方法而休眠的线程们。
实例演示
下面代码演示了CountDownLatch简单使用。演示的场景是5位运动员参加跑步比赛，发令枪打响后，5个计时器开始分别计时，直到所有运动员都到达终点。
public class CountDownLatchDemo {
public static void main(String[] args) {
Timer timer = new Timer(5);
new Thread(timer).start();
for (int athleteNo = 0; athleteNo < 5; athleteNo++) {
new Thread(new Athlete(timer, "athlete" + athleteNo)).start();
}
}
}
class Timer implements Runnable {
CountDownLatch timerController;
public Timer(int numOfAthlete) {
this.timerController = new CountDownLatch(numOfAthlete);
}
public void recordResult(String athleteName) {
System.out.println(athleteName + " has arrived");
timerController.countDown();
System.out.println("There are " + timerController.getCount() + " athletes did not reach the end");
}
@Override
public void run() {
try {
System.out.println("Start...");
timerController.await();
System.out.println("All the athletes have arrived");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class Athlete implements Runnable {
Timer timer;
String athleteName;
public Athlete(Timer timer, String athleteName) {
this.timer = timer;
this.athleteName = athleteName;
}
@Override
public void run() {
try {
System.out.println(athleteName + " start running");
long duration = (long) (Math.random() * 10);
Thread.sleep(duration * 1000);
timer.recordResult(athleteName);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
输出结果如下所示：
Start...
athlete0 start running
athlete1 start running
athlete2 start running
athlete3 start running
athlete4 start running
athlete0 has arrived
There are 4 athletes did not reach the end
athlete3 has arrived
There are 3 athletes did not reach the end
athlete2 has arrived
athlete1 has arrived
There are 1 athletes did not reach the end
There are 2 athletes did not reach the end
athlete4 has arrived
There are 0 athletes did not reach the end
All the athletes have arrived
方法解析
1.构造方法 CountDownLatch(int count)构造一个指定计数的CountDownLatch，count为线程将要等待的操作数。
2.await() 调用await方法后，使当前线程在锁存器(内部计数器)倒计数至零之前一直等待，进入休眠状态，除非线程被中断。如果当前计数递减为零，则此方法立即返回，继续执行。
3.await(long timeout, TimeUnit unit) 调用await方法后，使当前线程在锁存器(内部计数器)倒计数至零之前一直等待，进入休眠状态，除非线程被 中断或超出了指定的等待时间。如果当前计数为零，则此方法立刻返回true值。
3.acountDown() acountDown方法递减锁存器的计数，如果计数到达零，则释放所有等待的线程。如果当前计数大于零，则将计数减少。如果新的计数为零，出于线程调度目的，将重新启用所有的等待线程。
4.getCount() 调用此方法后，返回当前计数，即还未完成的操作数，此方法通常用于调试和测试。
源码解析
进入源码分析之前先看一下CountDownLatch的类图，
![]()
Sync是CountDownLatch的一个内部类，它继承了AbstractQueuedSynchronizer。
CountDownLatch(int count)、await()和countDown()三个方法是CountDownLatch的核心方法，本篇将深入分析这三个方法的具体实现原理。
1.CountDownLatch(int count)
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
该构造方法根据给定count参数构造一个CountDownLatch，内部创建了一个Sync实例。Sync是CountDownLatch的一个内部类，其构造方法代码如下：
Sync(int count) {
setState(count);
}
setState方法继承自AQS，给Sync实例的state属性赋值。
protected final void setState(int newState) {
state = newState;
}
这个state就是CountDownLatch的内部计数器。
2.await() 当await()方法被调用时，当前线程会阻塞，直到内部计数器的值等于零或当前线程被中断，下面深入代码分析。
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
//如果当前线程中断，则抛出InterruptedException
if (Thread.interrupted())
throw new InterruptedException();
//尝试获取共享锁，如果可以获取到锁直接返回；
//如果获取不到锁，执行doAcquireSharedInterruptibly
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
//如果当前内部计数器等于零返回1，否则返回-1；
//内部计数器等于零表示可以获取共享锁，否则不可以；
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
//返回内部计数器当前值
protected final int getState() {
return state;
}
//该方法使当前线程一直等待，直到当前线程获取到共享锁或被中断才返回
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
//根据当前线程创建一个共享模式的Node节点
//并把这个节点添加到等待队列的尾部
//AQS等待队列不熟悉的可以查看AQS深入解析的内容
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) {
//获取新建节点的前驱节点
final Node p = node.predecessor();
//如果前驱节点是头结点
if (p == head) {
//尝试获取共享锁
int r = tryAcquireShared(arg);
//获取到共享锁
if (r >= 0) {
//将前驱节点从等待队列中释放
//同时使用LockSupport.unpark方法唤醒前驱节点的后继节点中的线程
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
//当前节点的前驱节点不是头结点，或不可以获取到锁
//shouldParkAfterFailedAcquire方法检查当前节点在获取锁失败后是否要被阻塞
