public class CountDownLatch {

    private final Sync sync;

    public CountDownLatch(int count) {

        if (count < 0) throw new IllegalArgumentException("count < 0");

        this.sync = new Sync(count); // sync的锁状态（锁计数）state = count

    }

    public void await() throws InterruptedException {

        sync.acquireSharedInterruptibly(1);  // 参数1并未使用

    }

    public boolean await(long timeout, TimeUnit unit) throws InterruptedException {

        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));

    }

    public void countDown() {

        sync.releaseShared(1); // sync的锁状态（锁计数）state--，见Sync.tryReleaseShared

    }

    ... ...

}

private static final class Sync extends AbstractQueuedSynchronizer {

    Sync(int count) {

        setState(count); // sync的锁状态（锁计数）state = count

    }

    protected int tryAcquireShared(int acquires) {

        return (getState() == 0) ? 1 : -1; // 若state > 0（尝试取锁失败），则当前线程进入SyncQueue排队等锁

    }

    protected boolean tryReleaseShared(int releases) {

        for (;;) {

            // CAS(state)失败将回到此处

            int c = getState();                 /*记录state*/

            if (c == 0)

                return false;

            int nextc = c - 1;

            if (compareAndSetState(c, nextc))   /*CAS设置state -= 1*/

                return nextc == 0; // 若state为0（尝试释放锁成功），则唤醒所有在SyncQueue排队等锁的节点（线程）

        }

    }

}