CountDownLatch

CountDownLatch的作用是，让1个或者多个线程等待直到一些操作在其它的线程执行完程。

CountDownLatch的入参是一个数据类型，表示等待结束需要执行的countDown的次数。

CountDownLatch最主要的方法是await和countDown方法。

await

await调用了AQS的acquireSharedInterruptibly

public void await() throws InterruptedException {    sync.acquireSharedInterruptibly(1);
}

acquireSharedInterruptibly方法线判断线程是否被中断，如果被中断就抛出异常。

尝试获取资源，如果获取不到就阻塞获取。

public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}

tryAcquireShared方法的实现如下，判断state变量是否等于0，如果等于0，则说明需要等待的操作已经执行完成，就返回1表示不用等待，否则返回-1执行阻塞获取资源流程。

protected int tryAcquireShared(int acquires) {
    return (getState() == 0) ? 1 : -1;
}

接着调到AQS的doAcquireSharedInterruptibly方法

• 先把当前线程添加到队列里
• 判断当前节点前一个节点是否是头节点，如果是头节点，尝试获取资源，如果获取到资源，将当前节点设置为头节点，并且传播资源
• 判断获取失败之后是否需要park当前节点表示的线程，如果需要park线程，就park线程并返回线程是否被中断

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);
                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);
    }
}

setHeadAndPropagate先把当前节点设置为头节点，然后判断调用者是否指定需要传播，如果判断需要传播，而且下一个节点是共享节点，就唤醒下一个节点对应的线程。

private void setHeadAndPropagate(Node node, int propagate) {
    Node h = head; // Record old head for check below
    setHead(node);
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
        (h = head) == null || h.waitStatus < 0) {
        Node s = node.next;
        if (s == null || s.isShared())
            doReleaseShared();
    }
}

doReleaseShared先判断头节点的状态是不是SIGNAL，如果是，修改节点状态改为0，把后一个节点unpark。

private void doReleaseShared() {
    
    for (;;) {
        Node h = head;
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) {
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;            // loop to recheck cases
                unparkSuccessor(h);
            }
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
        if (h == head)                   // loop if head changed
            break;
    }
}

countDown

countDown方法调用AQS的releaseShared释放1个资源。

public void countDown() {
    sync.releaseShared(1);
}

releaseShared方法尝试释放资源，如果释放资源后所有资源都被释放了，tryReleaseShared返回了true，那么就会调用doReleaseShared将所有等待的线程unpark。

public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;    }
    return false;
}

释放资源的时候，判断是否全部释放，next是否等于0，如果是，就返回true，说明资源已经全部被释放，否则返回false。

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;
    }
}

总结

本节介绍了CountDownLatch的实现，引入了AQS的共享模式。

共享模式下doReleaseShared会将所有等待的SHARED节点都unpark。但是我们看doReleaseShared的代码时发现只unpark了1个节点，那这是怎么实现的呢。进入doAcquireSharedInterruptibly方法，发现线程是在一个for循环里park的，线程被unpark之后，会把自己设为头节点，然后unpark后1个节点，就这样1个个地释放，会把同步队列里的所有等待的SHARED节点全部释放。