1. 作用
CountDownLatch 是 JDK1.5 引入的 juc包下的其中一个工具类。
初始化时，指定一个 计数器, 调用CountDownLatch实例的await方法的 N个线程(多个线程也可以) 阻塞住，每当调用 同一个CountDownLatch实例 的 countDown方法 会使 计数器减1，计数器为0时，被await方法阻塞住的线程才可以被唤醒, 继续往下执行。
countDownLatch 适用于 一个或多个线程需等待其他线程各自执行完毕后再执行 的场景。
2. 代码示例
启动两个线程,一个主线程,一个子线程 ,用CountDownLatch的await阻塞住。
然后 启动其他的两个子线程 调用 countDown() 。
public static void main(String[] args) {
final CountDownLatch latch = new CountDownLatch(2);
System.out.println("主线程开始执行…… ……");
new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("子线程被await.....");
latch.await();
System.out.println("被await的子线程.....释放");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
new Thread(() -> {
try {
Thread.sleep(3000);
System.out.println("子线程：" + Thread.currentThread().getName() + "执行");
} catch (InterruptedException e) {
e.printStackTrace();
}
latch.countDown();
}).start();
//第二个子线程执行
new Thread(() -> {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("子线程：" + Thread.currentThread().getName() + "执行");
latch.countDown();
}).start();
try {
System.out.println("主线程被await.....");
latch.await();
System.out.println("被await的主线程.....释放");
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("主线程执行完毕");
}
2.2 运行结果
3. 源码解析
3.1 大致原理
CountDownLatch 仍然是基于 AQS 的 CLH队列 来实现 的 一把 锁。大体逻辑和ReentrantReadWriteLock读写锁里面的读锁 比较像。
CountDownLatch 初始化 传入的计数器 还是 aqs中的state字段,原先表示锁的重入次数, 调用await方法时候的 所有线程 都会包装成 一个Node 节点 入队。有意思的是,这个节点 和ReentrantReadWriteLock读写锁里面的读锁创建的节点 一模一样，是一个SHARED节点，表示共享的。
其他地方调用 countDown() 的时候 ,会对 state计数器减一, 如果多次调用countDown(),直到将state计数器减到0, 那么 就会 唤醒队列中，被await()阻塞住的 线程(Node节点)，来抢锁。是否成功抢锁的判断逻辑 也与其功能 吻合，就是判断 state计数器是否等于0。
抢锁成功的话, 就会接着 唤醒下一个 被await方法阻塞住的 SHARED 线程节点, 下一个线程被唤醒后 又能抢到锁，又要唤醒自己的下一个。直到 所有被await阻塞的await节点线程都被唤醒,直到队列为空。
这部分 和 ReentrantReadWriteLock读写锁里面的读锁 被唤醒时，需要以同样的方法叫醒后面所有的 读线程 来 持有读锁 来达到 读共享的效果的 逻辑 一模一样。
所以 CountDownLatch 是可以 支持 多个线程一起被 阻塞住，然后一起被释放的。
3.2 内部的Sync同步器
继承AbstractQueuedSynchronizer, 大部分的方法还是 复用的 父类AbstractQueuedSynchronizer 同步器的,只重写了 尝试加共享锁 tryAcquireShared（int acquires）以及 尝试释放共享锁 tryReleaseShared(int releases)。
3.2.1 tryAcquireShared（int acquires）
尝试加共享锁
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
是否加锁成功 只看 state 是否等于 0 ,state字段 就是 CountDownLatch 实例化的时候传入的计数器。
3.2.2 tryReleaseShared(int releases)
尝试解共享锁
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
3.3 CountDownLatch类
3.3.1 构造方法
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
会把计数器的值 传入 内部的 同步器Sync的构造方法中,并实例化内部同步器。
最终设置到同步器的 state字段里。
3.3.2 await()
阻塞 当前线程
调用同步器acquireSharedInterruptibly()方法,注意这个方法是可以被打断的, 打断 正在阻塞状态的线程, 抛出InterruptedException 异常 来结束 阻塞。
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
3.3.2.1 acquireSharedInterruptibly(1)
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
// tryAcquireShared(arg) 会尝试加一次锁
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
tryAcquireShared(arg) 会先尝试加一次共享锁, 这个方法 会钩到 CountDownLatch的同步器Sync重写父类的 tryAcquireShared（1）钩子方法，判断当前计数器(state)的值是否等于0。
//Sync
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
这里有可以引发出另一个现象 , 如果CountDownLatch 的计数器 被减到0 之后,是可以直接抢到锁的, 并不会阻塞。也就是说CountDownLatch 的计数器 减到0,之后其他线程再调用await()方法 都不会被阻塞，等于失效了。
当然 正常情况下, CountDownLatch还没有被减到0，或者压根没被减，这个时候就调
doAcquireSharedInterruptibly(arg)，来入队列，阻塞。
3.3.2.2. doAcquireSharedInterruptibly(arg)
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
// 创建SHARED节点,并加入队尾，如果队列还没有初始化,那么先初始化队列
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) {
// 入队之后, 可能这个时候 计数器 在该线程 入队的过程已经被减到0了，
final Node p = node.predecessor();
if (p == head) {
// 第一次进来 ，先抢一次锁，如果被减到0之后,直接抢锁成功,执行业务代码。
// 被唤醒之后,由于是 for (;;),那么 走到这里还会抢锁
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
// 否则 阻塞住当前线程
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
// 如果被打断的话,会抛出异常,结束阻塞状态
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
3.3.2.3. parkAndCheckInterrupt()
阻塞住当前线程。
3.3.3 countDown()
其实就是对state(计数器)-1,
3.3.3.1 releaseShared(int arg)
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
// 如果已经等于0, 说明被其他线程减完了，被await的线程也都被唤醒了，这里直接返回false,外面的判断就不等于true,不执行 释放await的线程的逻辑。
if (c == 0)
return false;
// 如果计数器不等于 0，那么 -1
int nextc = c-1;
// cas修改计数器的值,如果失败了 ，由于是for (;;),还是 重试cas，直到cas修改state的值成功。
if (compareAndSetState(c, nextc))
// 计数器是否被减到0了,减到0了，外面的判断就要释放 被阻塞的线程。
return nextc == 0;
}
}
3.3.3.2 doReleaseShared()
计数器被减到0，那么就会执行这个方法，唤醒阻塞的线程,抢锁后执行业务代码。
private void doReleaseShared() {
for (;;) {
// 这个头结点 在aqs里叫 前置节点，waitStatus是Node.SIGNAL状态的，然后thread字段是空的
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue; // loop to recheck cases
// 会走到这里, 唤醒头结点的下一个节点,就是第一个被await方法阻塞住的线程节点。
unparkSuccessor(h);
}
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
if (h == head) // loop if head changed
break;
}
}
这个时候, 在之前代码阻塞住的线程 就会 被唤醒，继续执行下面的代码
那么 由于不是被打断的，那么 parkAndCheckInterrupt() 里的 检测线程的打断标识 Thread.interrupted() 不会返回ture,就不会抛异常，则进入下一次循环。
下一次循环 由于抢锁 ,由于state等于0，那么抢锁成功, 可以 执行业务代码。
抢锁成功之后会调用 doReleaseShared 来 释放下一个 SHARED节点里的线程。
3.3.3.3 setHeadAndPropagate(node,r)
由于 调用await方法 ,线程包装的节点 都是 SHARED状态的,那么 就会被唤醒。就又会调到之前 doReleaseShared() 方法, 用unpark方法唤醒下一个SHARED节点里的线程。
下一个SHARED节点里的线程 被唤醒后, 还是走这个逻辑,那么 判断state=0之后，拿到锁 又会 调 setHeadAndPropagate(node,r) 唤醒下一个线程,执行之前的逻辑。
以此反复，直到 所有被await 方法阻塞住的SHARED节点里的线程都被唤醒，都抢到锁,都得以 继续执行 后面的业务代码。
