CountDownLatch 分析

参考 一行一行源码分析清楚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 相遇，那么就只会有一个成功了。