1 概述
前面一篇文章（）我们对CountDownLatch进行了简单的介绍，并对CountDownLatch的使用使用了例子展示，那么这一篇文章我们就要来看一看CountDownLatch底层到地是怎么实现的。
2 UML类图
注意上图仅仅展现了类关系，针对类内部的结构没有进行展示，从上面我们可以猜测CountDownLatch的内部功能的实现又和AQS这个玩意脱不了干系，多半又是通过在Sync里面实现AQS的基本方法来实现相应的功能的，那么具体怎么样，我们继续下面的学习。
3 源码分析
3.1 类的继承关系
public class CountDownLatch {
... ...
}可以看到CountDownLatch没有显示继承哪个父类或者实现哪个父接口，根据Java语言规定，可知其父类是Object。
3.2 内部类
private static final class Sync extends AbstractQueuedSynchronizer {
// 版本号
private static final long serialVersionUID = 4982264981922014374L;
// 构造器
Sync(int count) {
setState(count);
}
// 返回当前计数
int getCount() {
return getState();
}
// 试图在共享模式下获取对象状态
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
// 试图设置状态来反映共享模式下的一个释放
protected boolean tryReleaseShared(int releases) {
// 无限循环
for (;;) {
// 获取状态
int c = getState();
if (c == 0) // 没有被线程占有
return false;
// 下一个状态
int nextc = c-1;
if (compareAndSetState(c, nextc)) // 比较并且设置成功
return nextc == 0;
}
}
}从上面我们可以看出Sync类实现了AQS，并且实现了AQS的基本方法，而这两个基本方法就是CountDownLatch实现的核心。
3.3 属性
private final Sync sync;可以看到CountDownLatch类的内部只有一个Sync类型的属性，这个属性相当重要，后面会进行分析。
3.4 构造函数
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
// 初始化状态数
this.sync = new Sync(count);
}该构造函数可以构造一个用给定计数初始化的CountDownLatch，并且构造函数内完成了sync的初始化，并设置了状态数。
3.5 核心函数
（1）await
首先我们来看一下函数的调用过程。
此函数将会使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断。其源码如下
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}有源码可知，该函数最终会调用AQS的acquireSharedInterruptibly函数，
//共享模式获取锁，如果线程中断了则直接放弃获取
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
//判断线程是否中断，如果中断直接抛出异常
if (Thread.interrupted())
throw new InterruptedException();
//获取锁返回大于等于0，则表示获取成功，直接返回，否则进行自旋等待。
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}通过查看tryAcquireShared的源码，
protected int tryAcquireShared(int acquires) {
//同步状态为0的时候返回1，否则返回-1
return (getState() == 0) ? 1 : -1;
}我们看出仅仅当同步状态为0的时候才返回。而最初同步状态的值是在初始化CountDownLatch对象的时候设置进去的，这个值通过countDown会减小，直到为0。
我们再来看看自旋等待函数doAcquireSharedInterruptibly做了什么。
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
//以共享模式加入等待队列
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
//自旋等待（死循环）
for (;;) {
//获取当前节点的前节点
final Node p = node.predecessor();
//前节点为头节点，尝试获取锁
if (p == head) {
int r = tryAcquireShared(arg);
//获取成功，(state == 0时)
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);
}
}该方法的详细讲解我们可以查看JUC--AQS源码分析（二）同步状态的获取与释放。从上面我们可以看出要让线程结束等待要么线程中断，要么state == 0,那么什么时候state == 0呢？就是countDown() 执行了state次过后。下面我们再来看看countDown是怎么回事。
（2）countDown
依然我们来看一下函数的调用过程。
首先我们来看countDown,
public void countDown() {
sync.releaseShared(1);
}减小这个同步状态state(通过releaseShared的参数我们可以看出每次减小1)，当state减小至0的时候，等待线程阻塞结束，继续执行。
在countDown内部调用的AQS的模板方法releaseShared。
public final boolean releaseShared(int arg) {
//调用基本方法tryReleaseShared进行释放锁，释放成功返回true
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}从上面的源码我们可以看出，最终都要调用Sync的tryReleaseShared进行锁释放，而releaseShared的返回值对于countDown方法没有任何意义。
protected boolean tryReleaseShared(int releases) {
//死循环以保证释放当前线程对锁的持有
for (;;) {
int c = getState();
//state == 0,没有线程持有锁，直接返回
if (c == 0)
return false;
//减小持有锁的线程数，并使用CAS设置state的值，设置成功就直接返回，如果没有成功，
//继续循环设置，知道成功位置
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}我们可以看出来，tryReleaseShared其实就是减小了state。
通过上面对CountDownLatch的分析，其实对CountDownLatch的操作最终就是在操作state。可以总结出来主要是以下几步：
（1）初始化CountDownLatch的时候根据需要等待的线程数量来设置state的值。
（2）被等待的线程执行完的时候让state的值减1（通过countDown实现）。
（3）等待线程等待state == 0,当state == 0的时候结束等待，继续执行。
上面就是对CountDownLatch的学习总结，欢迎大家讨论不同见解。