死磕 java同步系列之CountDownLatch源码解析

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) {        // 注意，这里state等于0的时候返回的是1，也就是说count减为0的时候获取总是成功        // state不等于0的时候返回的是-1，也就是count不为0的时候总是要排队        return (getState() == 0) ? 1 : -1;    }    // 尝试释放锁    protected boolean tryReleaseShared(int releases) {        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;        }    }}

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

// java.util.concurrent.CountDownLatch.await()public void await() throws InterruptedException {    // 调用AQS的acquireSharedInterruptibly()方法    sync.acquireSharedInterruptibly(1);}// java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly()public final void acquireSharedInterruptibly(int arg)        throws InterruptedException {    if (Thread.interrupted())        throw new InterruptedException();    // 尝试获取锁，如果失败则排队    if (tryAcquireShared(arg) < 0)        doAcquireSharedInterruptibly(arg);}

// java.util.concurrent.CountDownLatch.countDown()public void countDown() {    // 调用AQS的释放共享锁方法    sync.releaseShared(1);}// java.util.concurrent.locks.AbstractQueuedSynchronizer.releaseShared()public final boolean releaseShared(int arg) {    // 尝试释放共享锁，如果成功了，就唤醒排队的线程    if (tryReleaseShared(arg)) {        doReleaseShared();        return true;    }    return false;}

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();                    // do sth                    System.out.println("Aid thread is doing something.");                    doneSignal.countDown();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }).start();        }
        // main thread do sth        Thread.sleep(2000);        System.out.println("Main thread is doing something.");        startSignal.countDown();
        // main thread do sth else        System.out.println("Main thread is waiting for aid threads finishing.");        doneSignal.await();
        System.out.println("Main thread is doing something after all threads have finished.");
    }}