CountDownLatch : 主线程同时启动所有子线程，等待所有子线程都执行完毕，才重新执行主线程；其内部的计数器继承了AQS，AQS内部维持了一个volatile变量 state,用来表示同步状态，
（1） CountDownLatch(int count) 初始化计数器：当执行CountDownLatch downCountDownLatch = new CountDownLatch(5)时，已初始化一个基于AQS的同步队列，并把传进来的计数器赋给AQS队列的stat【setState(count)】，stat的值也表示一个针对CountdownLatch当前剩余的计数次数；
// 继承了AQS
private static final class Sync extends AbstractQueuedSynchronizer {...}
/**
* 创建一个值为count的计数器
*/
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
// Sync 是CountDownLatch的一个内部类
this.sync = new Sync(count);
}
Sync(int count) {
// 继承自AQS
setState(count);
}
（2）void await()：阻塞当前进程：
当调用await的时候，当前线程会被阻塞，同时加入到AQS阻塞队列，实际上是调用了AQS的acquireSharedInterruptibly方法，当线程调用了await方法时，该线程将被阻塞，直到下面两种情况之一：
（a）当所有线程都调用了countDown方法，也就是计数值为0时，
（b）当前线程的interrupted()方法被其他线程调用，就会抛出InterruptedException异常
/**
* 阻塞当前进程，将当前进程加入阻塞队列
*/
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
//AQS获取共享资源时可被中断的方法，
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
//如果线程被中断则抛出异常
if (Thread.interrupted())
throw new InterruptedException();
//查看当前计数器值是否为0,
if (tryAcquireShared(arg) < 0)
// 调用AQS的doAcquireSharedInterruptibly方法让当前线程阻塞
// 实际上会构建阻塞队列的双向链表，挂起当前线程
doAcquireSharedInterruptibly(arg);
}
//sync类实现的AQS的接口
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
线程获取资源时可以被中断,并且获取的资源是共享资源.
（3）boolean await(long timeout, TimeUnit unit)
和public void await()区别仅在于当线程阻塞时间超过timeout时，会返回false，计数器为0时，则返回true，发生中断会抛出异常，而void await()方法没有返回值
（4）void countDown()：计数器减1，当计数值为0时，则释放所有因调用await方法阻塞的线程，否则什么都不做
public void countDown() {
//委托sync调用AQS的方法
sync.releaseShared(1);
}
//AQS的方法
public final boolean releaseShared(int arg) {
//调用sync实现的tryReleaseShared
if (tryReleaseShared(arg)) {
//AQS的释放资源方法
doReleaseShared();
return true;
}
return false;
}
// Syc 实现的tryReleaseShared
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;
// 调用AQS的cas
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
调用countDown()方法时是原子性递减AQS的state状态值，CountDownLatch中的Sync会优先尝试修改state的值，来获取同步状态。例如，如果某个线程成功的将state的值从0修改为1，表示成功的获取了同步状态。 这个修改的过程是通过CAS完成的，所以可以保证线程安全。
反之，如果修改state失败，则会将当前线程加入到AQS的队列中，并阻塞线程。
当CountDownLatch因异常导致计数值不能正常递减，最终到达0时，相应实例上的线程就会一直处于WAITING状态，有两种方式可避免出现这种现象：（a）调用countDown()方法时，尽量放在finally代码块内；（b）使用CountDownLatch.await(long,TimeUnit)方法，超时之后等待线程会自动唤醒
（5）long getCount():当前的计数器值
/**
* 返回当前计数器的值
*/
public long getCount() {
return sync.getCount();
}
// 其内部还是调用了 AQS 的getState来获取state值
int getCount() {
return getState();
}
CountDownLatch 是线程安全的
CountDownLatch和join的区别
使用join方法必须等待多个线程执行完毕之后才能解除阻塞状态，而CountDownLatch相对灵活，可以通过调用countDown方法来减少计数，唤醒被阻塞的线程
参考的实例
package com.example.lettcode.concurrent;
import cn.hutool.core.util.RandomUtil;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
/**
* @Class CountDownLatchDemo
* @Description TODO
* @Author
* @Date 2021/4/8
**/
public class CountDownLatchDemo {
public static void main(String[] args) {
int startCount = 1;
CountDownLatch startCountDownLatch = new CountDownLatch(startCount);
int downCount = 5;
CountDownLatch downCountDownLatch = new CountDownLatch(downCount);
for (int i = 0; i < downCount; i++) {
new Thread(new WorkerRunnable(startCountDownLatch, downCountDownLatch), "线程：" + i).start();
}
try {
// 休眠1s ，保证所有的线程都已经调用了await方法，进入阻塞状态
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("所有线程都已启动！！！");
// 唤醒所有阻塞的子线程
startCountDownLatch.countDown();
System.out.println("等待所有线程执行结束！！！");
try {
// 此处是为了让主线程阻塞，等待所有子线程执行完毕
downCountDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("所有任务都已执行结束！！！");
}
static class WorkerRunnable implements Runnable {
private CountDownLatch startCountDownLatch;
private CountDownLatch downCountDownLatch;
public WorkerRunnable(CountDownLatch startCountDownLatch, CountDownLatch downCountDownLatch) {
this.startCountDownLatch = startCountDownLatch;
this.downCountDownLatch = downCountDownLatch;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 已经准备好。。。");
try {
// 等待所有子线程都准备完毕再开始
startCountDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
childThreadWork();
try {
downCountDownLatch.countDown();
} catch (Exception e) {
e.printStackTrace();
}
}
private void childThreadWork() {
System.out.println(Thread.currentThread().getName() + "开始执行");
try {
TimeUnit.SECONDS.sleep(RandomUtil.randomInt(5));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
