参考 一行一行源码分析清楚AQS
AQS 独占锁：只能有一个线程持有锁，获取锁失败的线程进入阻塞队列，持有锁的线程释放锁之后会唤醒等待队列中的第一个线程，让其来占有锁
AQS 共享锁：允许多个线程同时持有锁，当队列中的等待线程被唤醒以后就重新尝试获取锁资源，如果成功则唤醒后面还在等待的共享节点并把该唤醒事件传递下去，
即会依次唤醒在该节点后面的所有共享节点
waitStatus 值为0，代表初始化状态，值为-1 代表后续一个节点需要被唤醒。
AQS在判断状态时，通过用waitStatus>0表示取消状态，而waitStatus<0表示有效状态。
CountDownLatch就是利用AQS的共享锁机制来实现的。
假设有4个线程，t1,t2,t3,t4. t1,t2调用countdown()方法，t3,t4调用await()方法
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
// 调用 await 的时候，state都是小于 0。
// 也就是说，这个 if 返回 true，然后往里看
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
// 只有当 state == 0 的时候，这个方法才会返回 1 state==0 代表可以唤醒阻塞的线程了
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
// 获取共享锁
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
// 1. 入队
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head) {
// head == p 代表当前节点是阻塞队列的第一个节点
//只要 state 不等于 0，那么这个方法返回 -1，也就是下面这个if判断进不去
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
// 到 shouldParkAfterFailedAcquire 的时候，t3 将 head 的 waitStatus 值设置为 -1，代表之后的一个线程需要被唤醒
if (shouldParkAfterFailedAcquire(p, node) &&
//然后进入到 parkAndCheckInterrupt 的时候，t3 挂起。
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
t4 入队，t4 会将前驱节点 t3 所在节点的 waitStatus 设置为 -1,然后 t4 也挂起。为什么需要把前面节点waitStatus 设置为 -1，我觉得是给定一种信号，共享锁模式下，每个共享节点入队都会把waitStatus 设置为 -1，代表自己后面要被唤醒。接下来，t3 和 t4 就等待唤醒了。
public void countDown() {
sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
// 只有当 state 减为 0 的时候，tryReleaseShared 才返回 true，然后执行唤醒操作
// 否则只是将 state = state - 1 那么 countDown 方法就结束了
if (tryReleaseShared(arg)) {
// 唤醒 await 的线程
doReleaseShared();
return true;
}
return false;
}
//用CAS自旋的方法实现 state 减 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;
}
}
// 开始释放锁，然后执行唤醒操作
private void doReleaseShared() {
for (;;) {
Node h = head;
// 1. h == null: 说明阻塞队列为空
// 2. h == tail: 说明头结点可能是刚刚初始化的头节点，
// 或者是普通线程节点，但是此节点既然是头节点了，那么代表已经被唤醒了，阻塞队列没有其他节点了
// 所以这两种情况不需要进行唤醒后继节点
if (h != null && h != tail) {
int ws = h.waitStatus;
// t3 入队的时候，已经将头节点的 waitStatus 设置为 Node.SIGNAL（-1） 了
if (ws == Node.SIGNAL) {
// 利用CAS将前驱节点的waitStatus值置为0，清空当前节点即t3需要被唤醒的信号，
// 因为马上就要唤醒他了，避免重复唤醒 这里可能CAS失败，下面有解释
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue; // loop to recheck cases
// 唤醒 head 的后继节点，也就是阻塞队列中的第一个节点 在这里，也就是唤醒 t3
unparkSuccessor(h);
}
else if (ws == 0 &&
// 这个 CAS 失败的场景是：执行到这里的时候，刚好有一个节点入队，入队会将这个 ws 设置为 -1
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE)) // todo
continue; // loop on failed CAS
}
// 如果到这里的时候，前面唤醒的线程已经占领了 head，那么再循环
// 否则，就是 head 没变，那么退出循环，
// 退出循环之后唤醒的线程之后还是会调用这个方法的
if (h == head) // loop if head changed
break;
}
}
一旦 t3 被唤醒后，回到 await 的这段代码，parkAndCheckInterrupt 返回，接下来，t3 会进到 setHeadAndPropagate(node, r) 这个方法，先把 自己设置为head ，然后唤醒队列中后续线程：
private void setHeadAndPropagate(Node node, int propagate) {
Node h = head; // Record old head for check below
setHead(node);
// 下面说的是，唤醒当前 node 之后的节点，即t3醒了，唤醒t4,t4唤醒t5等等
// 也就是共享锁的思路
if (propagate > 0 || h == null || h.waitStatus < 0 ||
(h = head) == null || h.waitStatus < 0) {
Node s = node.next;
if (s == null || s.isShared())
// 现在的 head 已经不是原来的空节点了，是 t3 的节点
doReleaseShared();
}
}
解释下为什么第一个CAS可能会失败：
for 循环第一轮的时候会唤醒 t4，t4 醒后会将自己设置为头节点，如果在 t4 设置头节点后，for 循环才跑到
if (h == head)，那么此时会返回 false，for 循环会进入下一轮。t4 唤醒后也会进入到这个方法里面，
那么 for 循环第二轮和 t4 就有可能在这个 CAS 相遇，那么就只会有一个成功了。
