1、CountDownLatch介绍
CountDownLatch让一个或多个线程等待其他线程执行完成后再执行。在创建CountDownLatch对象时，必须指定线程数count，每当一个线程执行完成调用countDown()方法，线程数count减1，当count减到0时，await()方法就不再阻塞。
2、CountDownLatch使用
1 import java.util.concurrent.CountDownLatch;
2
3 public class TestCountDownLatch {
4 public static void main(String[] args) {
5 // 设置初始值
6 int count = 5;
7 CountDownLatch cdl = new CountDownLatch(count);
8 for (int i = 0; i < count; i++) {
9 Thread thread = new Thread(() -> {
10 System.out.println(Thread.currentThread().getName());
11 cdl.countDown();
12 });
13 // 设置当前线程为守护线程
14 thread.setDaemon(true);
15 // 启动线程
16 thread.start();
17 }
18 // 阻塞等待，直到state==0
19 try {
20 cdl.await();
21 } catch (InterruptedException e) {
22 e.printStackTrace();
23 }
24 // 主线程
25 System.out.println(Thread.currentThread().getName());
26 }
27 }
结合上面的代码示例，为了便于理解，将CountDownLatch的state变化及调用await()、countDown()方法后线程的情况用下图展示，详情如下：
3、CountDownLatch源码分析
CountDownLatch详情如下：
3.1、构造函数
CountDownLatch没有无参构造函数，在有参构造函数中初始化了sync属性。
1 public CountDownLatch(int count) {
2 // count 合法校验
3 if (count < 0) throw new IllegalArgumentException("count < 0");
4 // 初始化sync属性
5 this.sync = new Sync(count);
6 }
3.2、Sync - 队列同步器
1 // 抽象队列同步器
2 private static final class Sync extends AbstractQueuedSynchronizer {
3 private static final long serialVersionUID = 4982264981922014374L;
4
5 // 将 count 赋值给 AQS 的 state 属性
6 Sync(int count) {
7 setState(count);
8 }
9 // 获取 AQS 的 state 属性
10 int getCount() {
11 return getState();
12 }
13 // 判断所有线程是否都执行完成， 1 -> 全部执行完成；-1 -> 仍有线程在执行
14 protected int tryAcquireShared(int acquires) {
15 return (getState() == 0) ? 1 : -1;
16 }
17 // 释放锁
18 protected boolean tryReleaseShared(int releases) {
19 // 自旋
20 for (;;) {
21 // 获取 AQS 的 state
22 int c = getState();
23 // 锁资源已经释放完毕，再次进入，直接返回false，什么也不做
24 if (c == 0)
25 return false;
26 // state - 1
27 int nextc = c-1;
28 // CAS 赋值操作
29 if (compareAndSetState(c, nextc))
30 // 最后一个线程执行完，state = 0 ，返回true。
31 // countDown() 唤醒等待队列中的其他挂起线程
32 return nextc == 0;
33 }
34 }
35 }
3.3、await() - 阻塞等待
CountDownLatch#await()，详情如下：
1 // AQS的state属性不为0， 阻塞
2 public void await() throws InterruptedException {
3 // 调用AQS提供的获取共享锁并允许中断的方法
4 sync.acquireSharedInterruptibly(1);
5 }
AbstractQueuedSynchronizer#acquireSharedInterruptibly()，详情如下：
1 // 获取共享锁，并允许其中断
2 public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
3 // 线程中断，抛出异常
4 if (Thread.interrupted())
5 throw new InterruptedException();
6 // 获取共享锁，由CountDownLatch实现
7 if (tryAcquireShared(arg) < 0)
8 // state > 0，说明有线程在持有锁资源，将当前线程添加到AQS等待队列中
9 doAcquireSharedInterruptibly(arg);
10 }
CountDownLatch#Sync#tryAcquireShared()，详情如下：
1 // 获取共享锁
2 protected int tryAcquireShared(int acquires) {
3 // 线程全部执行完成，返回 1；未全部执行完成，返回-1
4 return (getState() == 0) ? 1 : -1;
5 }
AbstractQueuedSynchronizer#acquireSharedInterruptibly()，详情如下：
1 // 将当前线程添加到AQS等待队列中
2 private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
3 // 当前线程封装成Node，添加到AQS等待队列中
4 final Node node = addWaiter(Node.SHARED);
5 boolean failed = true;
6 try {
7 // 自旋
8 for (;;) {
9 // 获取当前线程节点的前驱节点
10 final Node p = node.predecessor();
11 // 前驱节点为等待队列头节点
12 if (p == head) {
13 // 调用 CountDownLatch 实现的方法
14 int r = tryAcquireShared(arg);
15 // 返回值为1，表示 state 为 0 ，所有线程都释放了锁，无其他线程持有锁资源
16 if (r >= 0) {
17 // state = 0，将当前线程和后面所有排队的线程都唤醒。
18 setHeadAndPropagate(node, r);
19 p.next = null;
20 failed = false;
21 return;
22 }
23 }
24 // *** 线程在此处被挂起，待所有线程释放锁资源后，即state = 0 ，线程被唤醒，再继续往下执行
25 // 挂起获取锁资源失败的线程，并且挂起的线程被中断，抛出InterruptedException异常
26 if (shouldParkAfterFailedAcquire(p, node) &&
27 parkAndCheckInterrupt())
28 throw new InterruptedException();
29 }
30 } finally {
31 if (failed)
32 cancelAcquire(node);
33 }
34 }
3.4、countDown() - 释放锁资源
CountDownLatch#countDown()，详情如下：1 // countDown方法, 实际上调用了AQS的释放共享锁操作
2 public void countDown() {
3 sync.releaseShared(1);
4 }
AbstractQueuedSynchronizer#releaseShared()，详情如下：
1 // AQS提供的释放共享锁方法，CountDownLatch实现了 tryReleaseShared 方法
2 public final boolean releaseShared(int arg) {
3 // 尝试释放锁资源
4 if (tryReleaseShared(arg)) {
5 // 没有线程持有锁资源，唤醒等待队列中的其他挂起线程
6 doReleaseShared();
7 return true;
8 }
9 return false;
10 }
CountDownLatch#Sync#tryReleaseShared()，详情如下：
1 protected boolean tryReleaseShared(int releases) {
2 // 自旋
3 for (;;) {
4 // 获取当前持有锁资源的线程数
5 int c = getState();
6 // state已为0，返回false，那么再次执行countDown，什么事情也不做
7 if (c == 0)
8 return false;
9 // count - 1
10 int nextc = c-1;
11 // CAS 完成赋值操作
12 if (compareAndSetState(c, nextc))
13 // 没有线程持有锁资源，返回true
14 return nextc == 0;
15 }
16 }
AbstractQueuedSynchronizer#doReleaseShared()，详情如下：
1 // 没有线程持有锁资源的处理
2 private void doReleaseShared() {
3 // 自旋
4 for (;;) {
5 // 获取等待队列的头节点
6 Node h = head;
7 // 等待队列中有挂起线程待唤醒
8 if (h != null && h != tail) {
9 int ws = h.waitStatus;
10 // 线程待唤醒
11 if (ws == Node.SIGNAL) {
12 if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
13 continue;
14 // 唤醒线程
15 unparkSuccessor(h);
16 }
17 // CAS失败
18 else if (ws == 0 &&
19 !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
20 continue;
21 }
22 // 等待队列头节点被改变，结束循环
23 if (h == head)
24 break;
25 }
26 }
3.5、总结
CountDownLatch基于 AQS + CAS 实现，CountDownLatch的构造函数中必须指定count，同时初始继承AQS的内部类Sync，通过Sync对象将count赋值给AQS的state属性，这样就可以基于AQS提供的方法完成CountDownLatch的功能。
调用countDown()方法，实际上是将AQS中 state 减 1。所有线程执行完成，state 会被修改为 0 ，在countDown()中会唤醒等待队列中挂起的线程。
调用await()方法，实际上是判断AQS中的 state 是否为 0。state > 0，表示有线程仍在执行，此时await()会阻塞线程。当最后一个线程执行结束，state 变为 0，countDown()唤醒线程后，await()正常执行结束，不再阻塞。
标签：分析,count,AQS,int,state,源码,线程,CountDownLatch From： https://www.cnblogs.com/RunningSnails/p/17360363.html