JUC-并发编程13-CountDownLatch倒计时器

1、简介

CountDownLatch，可以翻译为倒计时器，但是似乎不太准确，它的含义是允许一个或多个线程等待其它线程的操作执行完毕后再执行后续的操作。CountDownLatch的通常用法和Thread.join()有点类似，等待其它线程都完成后再执行主任务。

2、继承关系

CountDownLatch中只包含了Sync一个内部类，它没有公平/非公平模式，所以它算是一个比较简单的同步器了。

3、内部sync

private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;
        //构造方法初始化state
        Sync(int count) {
            setState(count);
        }
        // 获取还剩的次数
        int getCount() {
            return getState();
        }
        // 尝试获取共享锁
        protected int tryAcquireShared(int acquires) {
            // 注意，这里state等于0的时候返回的是1，也就是说count减为0的时候获取总是成功
            // state不等于0的时候返回的是-1，也就是count不为0的时候总是要排队
            return (getState() == 0) ? 1 : -1;
        }
        //尝试释放锁
        protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                //state的值
                int c = getState();
                //等于0了，则无法在释放了
                if (c == 0)
                    return false;
                // 将count的值减1
                int nextc = c-1;
                //原子更新state的值
                if (compareAndSetState(c, nextc))
                    //减为0的时候返回true，这时候唤醒后面排队的线程
                    return nextc == 0;
            }
        }
    }

 Sync重写了tryAcquireShared()和tryReleaseShared()方法，并把count存到state变量中去。

4、构造方法

public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

构造方法需要传入一个count，也就是初始次数。

5、await()方法

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

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

await()方法是等待其它线程完成的方法，它会先尝试获取一下共享锁，如果失败则进入AQS的队列中排队等待被唤醒。

根据上面Sync的源码，我们知道，state不等于0的时候tryAcquireShared()返回的是-1，也就是说count未减到0的时候所有调用await()方法的线程都要排队。

6、countDown方法

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

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

countDown()方法，会释放一个共享锁，也就是count的次数会减1。根据上面Sync的源码，我们知道，tryReleaseShared()每次会把count的次数减1，当其减为0的时候返回true，这时候才会唤醒等待的线程。注意，doReleaseShared()是唤醒等待的线程。

7、使用案例

public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch startSignal = new CountDownLatch(1);
        CountDownLatch doneSignal = new CountDownLatch(5);
        for (int i = 0; i <5 ; i++) {
            new Thread(() ->{
                try {
                    System.out.println("Aid thread is waiting for starting.");
                    startSignal.await();
                    System.out.println("Aid thread is doing something");
                    doneSignal.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
        // main thread do something
        Thread.sleep(2000);
        System.out.println("Main thread is doing something.");
        startSignal.countDown();
        // main thread do something else
        System.out.println("Main thread is waiting for aid thrads finishing.");
        doneSignal.await();
        System.out.println("Main thread is doing something after all threads have finished.");
    }
}

8、总结

1. CountDownLatch表示允许一个或多个线程等待其它线程的操作执行完毕后再执行后续的操作；
2. CountDownLatch使用AQS的共享锁机制实现；
3. CountDownLatch初始化的时候需要传入次数count；
4. 每次调用countDown()方法count的次数减1；
5. 每次调用await()方法的时候会尝试获取锁，这里的获取锁其实是检查AQS的state变量的值是否为0；
6. 当count的值（也就是state的值）减为0的时候会唤醒排队着的线程（这些线程调用await()进入队列）；

问题：

• CountDownLatch为什么使用共享锁？

答：前面我们分析ReentrantReadWriteLock的时候学习过AQS的共享锁模式，比如当前锁是由一个线程获取为互斥锁，那么这时候所有需要获取共享锁的线程都要进入AQS队列中进行排队，当这个互斥锁释放的时候，会一个接着一个地唤醒这些连续的排队的等待获取共享锁的线程，注意，这里的用语是“一个接着一个地唤醒”，也就是说这些等待获取共享锁的线程不是一次性唤醒的。说到这里，是不是很明白了？因为CountDownLatch的await()多个线程可以调用多次，当调用多次的时候这些线程都要进入AQS队列中排队，当count次数减为0的时候，它们都需要被唤醒，继续执行任务，如果使用互斥锁则不行，互斥锁在多个线程之间是互斥的，一次只能唤醒一个，不能保证当count减为0的时候这些调用了await()方法等待的线程都被唤醒。

• CountDownLatch与Thread.join()有何不同？

答：Thread.join()是在主线程中调用的，它只能等待被调用的线程结束了才会通知主线程，而CountDownLatch则不同，它的countDown()方法可以在线程执行的任意时刻调用。