CountDownLatch是一种java.util.concurrent包下一个同步工具类，它允许一个或多个线程等待直到在其他线程操作执行完成。
使用场景：
在开发过程中，经常会遇到需要在主线程中开启多条线程去并行执行任务，并且主线程需要等待所有子线程执行完毕后再进行汇总的场景，
CountDownLatch的内部提供了一个计数器，在构造闭锁时必须指定计数器的初始值，且计数器的初始值必须大于0。另外它还提供了一个countDown方法来操作计数器的值，每调用一次countDown方法计数器都会减1，直到计数器的值减为0,
它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。
CountDownLatch原理
CountDownLatch底层依靠的是AQS，通过构造函数初始化计数器时，实际上是
把计数器的值赋值给了AQS的state，也就是这里AQS的状态值来表示计数器值。
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
Sync(int count) {
setState(count);
}await方法
void await()方法，当前线程调用了CountDownLatch对象的await方法后，当前线程会被阻塞，直到出现下面情况之一时才会返回：
- 当所有线程都调用了CountDownLatch对象的countDown方法后，也就是说计时器值为 0 的时候。
- 其他线程调用了当前线程的interrupt（）方法中断了当前线程，当前线程会抛出InterruptedException异常后返回。接下来让我们看看await（）方法内部是如何调用
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
//AQS的获取共享资源时候可被中断的方法
public final void acquireSharedInterruptibly(int arg)throws InterruptedException {
//如果线程被中断则抛异常
if (Thread.interrupted())
throw new InterruptedException();
//尝试看当前是否计数值为0，为0则直接返回，否者进入AQS的队列等待
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
//sync类实现的AQS的接口
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}从上面代码可以看到await（）方法委托sync调用了AQS的acquireSharedInterruptibly方法，该方法的特点是线程获取资源的时候可以被中断，并且获取到的资源是共享资源，这里为什么要调用AQS的这个方法，而不是调用独占锁的accquireInterruptibly方法呢？这是因为这里状态值需要的并不是非 0 即 1 的效果，而是和初始化时候指定的计数器值有关系，比如你初始化的时候计数器值为 8 ，那么state的值应该就有 0 到 8 的状态，而不是只有 0 和 1 的独占效果。
这里await（）方法调用acquireSharedInterruptibly的时候传递的是 1 ，就是说明要获取一个资源，而这里计数器值是资源总数，也就是意味着是让总的资源数减 1 ，acquireSharedInterruptibly内部首先判断如果当前线程被中断了则抛出异常，否则调用sync实现的tryAcquireShared方法看当前状态值(计数器值)是否为 0 ，是则当前线程的await（）方法直接返回，否则调用AQS的doAcquireSharedInterruptibly让当前线程阻塞。另外调用tryAcquireShared的方法仅仅是检查当前状态值是不是为 0 ，并没有调用CAS让当前状态值减去 1 。
boolean await(long timeout, TimeUnit unit)
当线程调用了 CountDownLatch 对象的该方法后，当前线程会被阻塞，直到出现下面情况之一时才会返回：
- 当所有线程都调用了 CountDownLatch 对象的 countDown 方法后，也就是计时器值为 0 的时候，这时候返回 true.
- 设置的 timeout 时间到了，因为超时而返回 false.
- 其它线程调用了当前线程的 interrupt（）方法中断了当前线程，当前线程会抛出 InterruptedException 异常后返回。
public boolean await(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}countDown方法
void countDown() 当前线程调用了该方法后，会递减计数器的值，递减后如果计数器为 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;
}如上面代码可以知道CountDownLatch的countDown（）方法是委托sync调用了AQS的releaseShared方法，后者调用了sync 实现的AQS的tryReleaseShared
protected boolean tryReleaseShared(int releases) {
//循环进行cas，直到当前线程成功完成cas使计数值（状态值state）减一并更新到state
for (;;) {
int c = getState();
//如果当前状态值为0则直接返回（1）
if (c == 0)
return false;
//CAS设置计数值减一（2）
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}如上代码可以看到首先获取当前状态值(计数器值)，代码（1）如果当前状态值为 0 则直接返回 false ，则countDown（）方法直接返回；否则执行代码（2）使用CAS设置计数器减一，CAS失败则循环重试，否则如果当前计数器为 0 则返回 true 。返回 true 后，说明当前线程是最后一个调用countDown()方法的线程，那么该线程除了让计数器减一外，还需要唤醒调用CountDownLatch的await 方法而被阻塞的线程。这里的代码（1）貌似是多余的，其实不然，之所以添加代码 (1) 是为了防止计数器值为 0 后，其他线程又调用了countDown方法，如果没有代码（1），状态值就会变成负数。
getCount（）方法
long getCount() 获取当前计数器的值，也就是 AQS 的 state 的值。
public long getCount() {
return sync.getCount();
}
int getCount() {
return getState();
}如上代码可知内部还是调用了 AQS 的 getState 方法来获取 state 的值（计数器当前值）。
使用方法（案例）
public class CountDownLatchTest {
private static AtomicInteger id = new AtomicInteger();
// 创建一个CountDownLatch实例，管理计数为ThreadNum
private static volatile CountDownLatch countDownLatch = new CountDownLatch(3);
public static void main(String[] args) throws InterruptedException {
Thread threadOne = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("【玩家" + id.getAndIncrement() + "】已入场");
countDownLatch.countDown();
}
});
Thread threadTwo = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("【玩家" + id.getAndIncrement() + "】已入场");
countDownLatch.countDown();
}
});
Thread threadThree = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("【玩家" + id.getAndIncrement() + "】已入场");
countDownLatch.countDown();
}
});
// 启动子线程
threadOne.start();
threadTwo.start();
threadThree.start();
System.out.println("等待斗地主玩家进场");
// 等待子线程执行完毕，返回
countDownLatch.await();
System.out.println("斗地主玩家已经满人，开始发牌.....");
}
}OutPut：
等待斗地主玩家进场
【玩家0】已入场
【玩家1】已入场
【玩家2】已入场
斗地主玩家已经满人，开始发牌.....如上代码，创建了一个 CountDownLatch 实例，因为有三个子线程所以构造函数参数传递为 3，主线程调用 countDownLatch.await（）方法后会被阻塞。子线程执行完毕后调用countDownLatch.countDown() 方法让 countDownLatch 内部的计数器减一，等所有子线程执行完毕调用 countDown（）后计数器会变为 0，这时候主线程的 await（）才会返回。
CountDownLatch 与 join 方法的区别，一个区别是调用一个子线程的 join（）方法后，该线程会一直被阻塞直到该线程运行完毕，而 CountDownLatch 则使用计数器允许子线程运行完毕或者运行中时候递减计数，也就是 CountDownLatch 可以在子线程运行任何时候让 await 方法返回而不一定必须等到线程结束；另外使用线程池来管理线程时候一般都是直接添加 Runable 到线程池这时候就没有办法在调用线程的 join 方法了，countDownLatch 相比 Join 方法让我们对线程同步有更灵活的控制。
转自： https://www.omgleoo.top/%E4%B8%80%E7%AF%87%E5%85%B3%E4%BA%8Ecountdownlatch%E7%9A%84%E5%A5%BD%E6%96%87%E7%AB%A0/