CountDownLatch用例、源码分析讲解

今天博主来讲解下J.U.C下的countdownlatch，它是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程的操作执行完毕再执行。从命名可以解读到 countdown 是倒数的意思，类似于我们倒计时的概念。countdownlatch 提供了两个方法，一个是 countDown，一个是 await，countdownlatch 初始化的时候需要传入一个整数，在这个整数倒数到 0 之前，调用了 await 方法的程序都必须要等待，然后通过 countDown 来倒数。

使用案例

public static void main(String[] args) throws InterruptedException {
    CountDownLatch countDownLatch=new CountDownLatch(3);
    new Thread(()->{
        System.out.println(""+Thread.currentThread().getName()+"-执行中");
        countDownLatch.countDown();
        System.out.println(""+Thread.currentThread().getName()+"-执行完毕");
    },"t1").start();
    new Thread(()->{
       System.out.println(""+Thread.currentThread().getName()+"-执行中");
       countDownLatch.countDown();
       System.out.println(""+Thread.currentThread().getName()+"-执行完毕");
    },"t2").start();
    new Thread(()->{
       System.out.println(""+Thread.currentThread().getName()+"-执行中");
       countDownLatch.countDown();
       System.out.println(""+Thread.currentThread().getName()+"-执行完毕");
    },"t3").start();
     countDownLatch.await();
     System.out.println("所有线程执行完毕");
}

从代码的实现来看，有点类似 join 的功能，但是比 join 更加灵活。CountDownLatch 构造函数会接收一个 int 类型的参数作为计数器的初始值，当调用 CountDownLatch 的countDown 方法时，这个计数器就会减一。通过 await 方法去阻塞去阻塞主流程:

模拟高并发场景

static CountDownLatch 
　　countDownLatch=new CountDownLatch(1);
 
@Override
public void run() {
try {
　　countDownLatch.await();
} catch (InterruptedException e) {
　　e.printStackTrace();
}
 
System.out.println("ThreadName:" + Thread.currentThread().getName());
}
 
public static void main(String[] args) throws InterruptedException {
　　for (int i = 0; i < 1000; i++) {
　　　　new Demo().start();
　　}
　　countDownLatch.countDown();
}

总的来说，凡事涉及到需要指定某个人物在执行之前，要等到前置人物执行完毕之后才执行的场景，都可以使用CountDownLatch。

CountDownLatch 源码分析

对于 CountDownLatch，我们仅仅需要关心两个方法，一个是 countDown() 方法，另一个是 await() 方法。countDown() 方法每次调用都会将 state 减 1，直到state 的值为 0；而 await 是一个阻塞方法，当 state 减为 0 的时候，await 方法才会返回。await 可以被多个线程调用，大家在这个时候脑子里要有个图：所有调用了await 方法的线程阻塞在 AQS 的阻塞队列中，等待条满足（state == 0），将线程从队列中一个个唤醒过来。acquireSharedInterruptiblycountdownlatch 也用到了 AQS，在 CountDownLatch 内部写了一个 Sync 并且继承了 AQS 这个抽象类重写了 AQS中的共享锁方法。首先看到下面这个代码，这块代码主要是判断当前线程是否获取到了共享锁 ; （在CountDownLatch 中，使用的是共享锁机制，因为CountDownLatch 并不需要实现互斥的特性）。

public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
　　if (Thread.interrupted()) throw new InterruptedException();
　　if (tryAcquireShared(arg) < 0) // state 如果不等于 0，说明当前线程需要加入到共享锁队列中
　　doAcquireSharedInterruptibly(arg);
}

doAcquireSharedInterruptibly

1. addWaiter 设置为 shared 模式。

2. tryAcquire 和 tryAcquireShared 的返回值不同，因此会多出一个判断过程。

3. 在判断前驱节点是头节点后，调用了setHeadAndPropagate 方法，而不是简单的更新一下头节点。

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) {// r>=0 表示获取到了执行权限，这个时候因为 state!=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);
　　}
}

图解分析

加入这个时候有 3 个线程调用了 await 方法，由于这个时候 state 的值还不为 0，所以这三个线程都会加入到 AQS队列中。并且三个线程都处于阻塞状态。

CountDownLatch.countDown

由于线程被 await 方法阻塞了，所以只有等到countdown 方法使得 state=0 的时候才会被唤醒，我们来看看 countdown 做了什么。

1. 只有当 state 减为 0 的时候，tryReleaseShared 才返回 true, 否则只是简单的 state = state - 1。

2. 如果 state=0, 则调用 doReleaseShared唤醒处于 await 状态下的线程。

public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }
 
    // 用自旋的方法实现 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;
        }
    }

AQS. doReleaseShared

共享锁的释放和独占锁的释放有一定的差别前面唤醒锁的逻辑和独占锁是一样，先判断头结点是不是SIGNAL 状态，如果是，则修改为 0，并且唤醒头结点的下一个节点。

PROPAGATE：标识为 PROPAGATE 状态的节点，是共享锁模式下的节点状态，处于这个状态下的节点，会对线程的唤醒进行传播。

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;
                    // 循环复查案例
                    unparkSuccessor(h);
                }
                // 这个 CAS 失败的场景是：执行到这里的时候，刚好有一个节点入队，入队会将这个 ws 设置为 -1
                else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;
                // 失败的CAS上的循环
            }
            // 如果到这里的时候，前面唤醒的线程已经占领了 head，那么再循环
            // 通过检查头节点是否改变了，如果改变了就继续循环
            if (h == head)
                // loop if head changed
                break;
        }
    }

h == head：说明头节点还没有被刚刚用unparkSuccessor 唤醒的线程（这里可以理解为ThreadB）占有，此时 break 退出循环。h != head：头节点被刚刚唤醒的线程（这里可以理解为ThreadB）占有，那么这里重新进入下一轮循环，唤醒下一个节点（这里是 ThreadB ）。我们知道，等到ThreadB 被唤醒后，其实是会主动唤醒 ThreadC...doAcquireSharedInterruptibly一旦 ThreadA 被唤醒，代码又会继续回到doAcquireSharedInterruptibly 中来执行。如果当前 state满足=0 的条件，则会执行 setHeadAndPropagate 方法。

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; // 把当前节点移除 aqs 队列
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

setHeadAndPropagate

这个方法的主要作用是把被唤醒的节点，设置成 head 节点。然后继续唤醒队列中的其他线程。由于现在队列中有 3 个线程处于阻塞状态，一旦 ThreadA被唤醒，并且设置为 head 之后，会继续唤醒后续的ThreadB。

private void setHeadAndPropagate(Node node, int propagate) {
        Node h = head; // 记录旧head以便检查
        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();
        }
    }