关于java:通俗易懂的JUC源码剖析CountDownLatch

前言

在理论开发中，有时会遇到这样的场景：主工作须要期待若干子工作实现后，再进行后续的操作。这时能够用join或者本文的CountDownLatch实现。它们的区别在于CountDownLatch更加灵便。比方，子工作的工作分为两个阶段，主工作只需子工作实现第一个阶段即可开始主工作，无需等第二个阶段实现。这种场景join就无奈做到，CountDownLatch就能够实现。上面是实例代码。

import java.util.concurrent.CountDownLatch;
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(2);
        Worker worker1 = new Worker("worker1", countDownLatch);
        Worker worker2 = new Worker("worker2", countDownLatch);
        worker1.start();
        worker2.start();
        System.out.println("main task wait for work1 and work2 finish their stage 1");
        countDownLatch.await();
        System.out.println("main task begin to work");
        Thread.sleep(3000);
        System.out.println("main task finished");
    }
    
    static class Worker extends Thread {
        private final CountDownLatch count;
        public Worker(String name, CountDownLatch count) {
            super.setName(name);
            this.count = count;
        }
        @Override
        public void run() {
            try {
               Thread.sleep(5000);
               System.out.println(Thread.currentThread().getName() + " stage 1 finished");
               count.countDown();
               Thread.sleep(5000);
               System.out.println(Thread.currentThread().getName() + " stage 2 finished");
            } catch (InterruptedException e) {
                // ignore
            }
        }
    }
}

运行后果如下：

主线程期待work1和work2实现它们的第一个阶段工作后，就开始工作，无需期待第二个阶段也实现。而join只能期待子线程整个run()执行结束能力往后执行，因而CountDownLatch更加灵便。

实现原理

从CountDownLatch的命名可猜想，它外部应该用了一个计数器，每当子线程调用countDown()办法时，计数器就减1，减到0时，主线程就会从调用await()阻塞处昏迷返回。

先来看看构造方法：

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

其中Sync是它的外部类，实现了AQS接口。

private static final class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = 4982264981922014374L;
    Sync(int count) {
        setState(count);
    }
    int getCount() {
        return getState();
    }
    protected int tryAcquireShared(int acquires) {
        // 计数器为0，则获取锁胜利，能够从await()返回
        // 否则须要期待
        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;
            // 计数器减1
            int nextc = c-1;
            if (compareAndSetState(c, nextc))
                // 减到0时会unpark唤醒阻塞在await()的线程
                return nextc == 0;
        }
    }
}

能够看到，它是一个共享锁实现，多个线程通过Sync来同步计数器count的值。

再来看罕用的await()和countDown()办法：

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

await()调用的是AQS中的模板办法：

public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    // 调用子类Sync的tryAcquireShared办法，如果共享式获取锁失败，doAcquireSharedInterruptibly外面会让以后线程在队列里阻塞期待获取锁。
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}

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

countDown调用的也是AQS中的模板办法：

public final boolean releaseShared(int arg) {
    // 调用子类Sync的tryReleaseShared()共享式地开释锁，
    // 计数器减为0时，doReleaseShared外面会唤醒期待在await()办法处的线程。
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true; 
    }
    return false;
}

参考资料：
《Java并发编程之美》