CountDownLatch 源码分析：
1：CountDownLatch数据结构
成员变量 Sync类型对象
private final Sync sync; Sync是继承AQS的一个类，CountDownLatch是通过AQS和CAS来实现它的锁的功能的；
2构造方法：
public CountDownLatch(int count) { //需要等待调用countDown() 的次数 这个例子中count=5 来举例说明
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count); //创建Sync对象，AQS的子类
}
Sync(int count) {
setState(count); //设置AQS类中state=count=5 state 是volitle修饰的
}
3：await 方法分析：
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1); //调用AQS中的acquireSharedInterruptibly方法
}
AQS. acquireSharedInterruptibly() 源码如下：
public final void acquireSharedInterruptibly(int arg) // arg=1
throws InterruptedException {
if (Thread.interrupted()) // 当前线程是否中断状态 如果中断则抛出异常
throw new InterruptedException();
if (tryAcquireShared(arg) < 0) //尝试获取共享锁
doAcquireSharedInterruptibly(arg);
}
tryAcquireShared方法如下：
protected int tryAcquireShared(int acquires) { // acquires=1
return (getState() == 0) ? 1 : -1; //state=5 表明未获取到锁，则返回 -1
}
返回-1后满足tryAcquireShared(arg) < 0这个条件，则进入doAcquireSharedInterruptibly(arg);
这个方法：下面对这个方法分析：
在分析这个源码之前，说明下 for(;;) 的作用：不断的轮询，相当于while(true)
private void doAcquireSharedInterruptibly(int arg) // arg=1
throws InterruptedException {
创建当前线程的节点，并且锁的模型是 共享锁 将其添加到AQS CLH队列的末尾
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) { //轮询以下代码的逻辑
final Node p = node.predecessor(); //获取前继节点
if (p == head) { //前继节点是表头则进入以下逻辑
int r = tryAcquireShared(arg); //尝试获取锁 这里state=5 获取锁失败
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);
}
}
下面对shouldParkAfterFailedAcquire 这个方法进行分析，这个之前在公平锁中有过分析
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus; //for(;;)第一次进入是waitStatus=0
if (ws == Node.SIGNAL)
return true; //第二次进入的时候返回 true
if (ws > 0) {
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
compareAndSetWaitStatus(pred, ws, Node.SIGNAL); //设置waitStatus=-1
}
return false;
}
接下来分析下 countDown方法：
public void countDown() {
sync.releaseShared(1);
}
releaseShared的方法如下： 目的 将AQS中的state -1,当state减到0的时候返回true
public final boolean releaseShared(int arg) { // arg=1
if (tryReleaseShared(arg)) {
doReleaseShared(); //这段代码的作用是unpark 被await 的线程；
具体的实现是：调用后继节点的LockSupport.unpark(s.thread); 这里的s节点就是head节点的后继节点；也就是前面调用await被挂起的线程节点
return true;
}
return false;
}
通过这里的countDown方法，就和之前的await()方法呼应起来了。实现了，某一个线程等待其他线程执行结束后再执行这个线程