// 基于 JDK 17 (本地 ms-17.0.18), java.util.concurrent.CountDownLatch
public class CountDownLatch {

    // 内部同步器。CountDownLatch 自己不写任何并发逻辑，全部委托给 AQS
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;

        Sync(int count) {
            setState(count);    // state 被赋予"剩余计数"的含义，构造时一次写入，之后只减不增
        }

        int getCount() {
            return getState();
        }

        // 共享获取：语义是"问门开没开"，不消耗任何资源，所以只读不写、没有 CAS。
        // 返回 1 = 门开(state==0)直接过；返回 -1 = 没开，回 AQS 入队挂起
        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }

        // 共享释放：CAS 自旋减一。整个类唯一有竞争的地方就在这
        protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;   // 已归零就直接失败：多余的 countDown 无害，state 永不为负，也不会重复触发唤醒
                int nextc = c - 1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;  // 只有"减到 0 的那一次"返回 true → AQS 才去 signalNext。N 次 countDown 只有一次触发唤醒
            }
        }
    }

    private final Sync sync;

    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);    // count==0 合法：等价于一个天生开着的门，await 直接过
    }

    // 阻塞等待归零，可中断。用的是共享+可中断版获取
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    // 带超时版：超时返回 false 而不是永远卡死，生产代码里几乎总该用这个
    public boolean await(long timeout, TimeUnit unit)
        throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

    // 减一，归零时放行所有 await 线程。注意它自己从不阻塞
    public void countDown() {
        sync.releaseShared(1);
    }

    public long getCount() {
        return sync.getCount();
    }

    // ... 省略 toString
}

// 基于 JDK 17 (本地 ms-17.0.18), java.util.concurrent.locks.AbstractQueuedSynchronizer
public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {

    // ...

    // await() 的入口。注意中断检查在 tryAcquireShared 之前：进门先看中断标记，被中断过就不排队直接抛
    public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
        if (Thread.interrupted() ||
            (tryAcquireShared(arg) < 0 &&
             acquire(null, arg, true, true, false, 0L) < 0))    // shared=true, interruptible=true；返回负数=排队期间被中断
            throw new InterruptedException();
    }

    // countDown() 的入口
    public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {    // 只有归零那一次为 true
            signalNext(head);           // 注意：只 unpark 队头后继"一个"线程，不是全部
            return true;
        }
        return false;
    }

    // 唤醒 h 的后继。先清 WAITING 状态再 unpark：被唤醒线程靠状态位区分"真信号"和虚假唤醒，防 park 竞态
    private static void signalNext(Node h) {
        Node s;
        if (h != null && (s = h.next) != null && s.status != 0) {
            s.getAndUnsetStatus(WAITING);
            LockSupport.unpark(s.waiter);
        }
    }

    // 和 signalNext 唯一区别：只对 SharedNode 生效，独占节点不传播
    private static void signalNextIfShared(Node h) {
        Node s;
        if (h != null && (s = h.next) != null &&
            (s instanceof SharedNode) && s.status != 0) {
            s.getAndUnsetStatus(WAITING);
            LockSupport.unpark(s.waiter);
        }
    }

    // 入队+阻塞的统一实现。只看共享模式获取成功后的那段：
    final int acquire(Node node, int arg, boolean shared,
                      boolean interruptible, boolean timed, long time) {
        // ...
                if (acquired) {
                    if (first) {
                        node.prev = null;
                        head = node;                    // 自己成为新 head
                        pred.next = null;
                        node.waiter = null;
                        if (shared)
                            signalNextIfShared(node);   // 关键：共享模式下，我过门后顺手叫醒下一个 → 唤醒沿队列链式传播
                        if (interrupted)
                            current.interrupt();
                    }
                    return 1;
                }
        // ...
    }
}