【JUC源码专题】CountDownLatch 核心源码分析（JDK8）

用法介绍

倒数闭锁，用于协调一组线程的工作。CountDownLatch 是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程的操作执行完后再执行。注：CountDownLatch 不能被重复使用（state 减到 0 以后就唤醒全部等待线程）。CyclicBarrier 可以重复使用。两者可以对比学习。

用法 1

某一线程在开始运行前等待 n 个线程执行完毕。将 CountDownLatch 的计数器初始化为 n。new CountDownLatch(n) ，每当一个任务线程执行完毕，就将计数器减 1 countdownlatch.countDown()，当计数器的值变为 0 时，在 CountDownLatch 上 await() 的线程就会被唤醒。一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行。

用法 2

实现多个线程开始执行任务的最大并行性。注意是并行性，不是并发，强调的是多个线程在某一时刻同时开始执行。类似于赛跑，将多个线程放到起点，等待发令枪响，然后同时开跑。做法是初始化一个共享的 CountDownLatch(1)，将其计数器初始化为 1，多个线程在开始执行任务前首先 coundownlatch.await()，当主线程调用 countDown() 时，计数器变为 0，多个线程同时被唤醒。

使用例子

    private static void usingCountDownLatch() {
        Thread[] threads = new Thread[100];
        CountDownLatch latch = new CountDownLatch(threads.length);
            
        for(int i=0; i<threads.length; i++) {
            threads[i] = new Thread(()->{
                int result = 0;
                for(int j=0; j<10000; j++) result += j;
                latch.countDown();
            });
        }
            
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }
            
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
            
        System.out.println("end latch");
    }

核心源码

学习完 AQS 的源码后，CDL 的源码就很简单了。但是需要注意 2 个点：

1. CDL 为什么不可重复使用
2. countDown 以后如何唤醒所有等待线程

Sync

Sync 是 CountDownLatch 的内部类，继承自 [[01 JDK8/JUC/locks/AbstractQueuedSynchronizer|AQS]]。

    private static final class Sync extends AbstractQueuedSynchronizer {
        Sync(int count) {
            setState(count);
        }

        int getCount() {
            return getState();
        }

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

        protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }

await 获取共享锁

调用 AQS 中的 acquireSharedInterruptibly 方法然后回调 tryAcquireShared 方法

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

tryAcquireShared

      protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1; // state 不为 0 时一直阻塞
        }

注：当 state 为 0 时，tryAcquireShared 永远返回 1。不会继续往下执行 doAcquireSharedInterruptibly 方法。即 CountDownLatch 是一次性的锁，不能重复使用。也即使用 countdonw 把 state 减到 0 以后，再调用 await 也没用了。

countDown 释放共享锁

调用 AQS 中的 releaseShared 方法然后回调 tryReleaseShared 方法释放共享锁

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

tryReleaseShared

        // 释放共享锁
        protected boolean tryReleaseShared(int releases) {
            // 死循环
            for (;;) {
                int c = getState();
                // 若 state 等于 0，则不能再次使用
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0; // 若 state 等于 0，则释放共享锁唤醒等待线程
            }
        }
    }

注意这行代码 return nextc == 0;，当 state 第一次等于 0 时。tryReleaseShared 方法会返回 true。然后会调用 doReleaseShared 唤醒后继结点。被唤醒的结点执行 tryAcquireShared 时，getState() == 0 成立，于是返回 1。然后执行 setHeadAndPropagate，因为 r 此时为 1，满足条件 propagate > 0，所以继续唤醒下一个结点，于是乎就唤醒了全部等待共享锁的线程。