// 基于 JDK 17, java.util.concurrent.CyclicBarrier
public class CyclicBarrier {

    // 每一轮汇合用一个 Generation 对象标识。放行(trip)或 reset 都会换新一代;
    // 等待线程靠 "generation 引用还是不是我进来时那个" 判断本轮是否已结束
    private static class Generation {
        Generation() {}
        boolean broken;                 // 本代是否被打破(中断/超时/回调抛异常/reset), 只在持锁时读写, 不需要 volatile
    }

    private final ReentrantLock lock = new ReentrantLock();    // 一把独占锁保护全部可变状态
    private final Condition trip = lock.newCondition();        // 未到齐的线程全挂在这一个条件队列上
    private final int parties;                                 // 参与方总数 N, 不可变 —— 可循环的前提是它和 count 分开存
    private final Runnable barrierCommand;                     // 到齐后、放行前执行的回调, 可为 null
    private Generation generation = new Generation();

    private int count;                  // 本代还差几个线程; 从 parties 减到 0, 换代或打破时复位

    public CyclicBarrier(int parties, Runnable barrierAction) {
        if (parties <= 0) throw new IllegalArgumentException();
        this.parties = parties;
        this.count = parties;
        this.barrierCommand = barrierAction;    // 典型用法: 所有分片算完后在这里合并结果
    }

    public CyclicBarrier(int parties) {
        this(parties, null);
    }

    // ...
}

// 基于 JDK 17, java.util.concurrent.CyclicBarrier
// 放行 + 复位: "可循环"的全部实现就这三行
private void nextGeneration() {
    trip.signalAll();                   // 唤醒本代所有等待者
    count = parties;                    // 计数复位, 下一轮直接可用
    generation = new Generation();      // 换新对象而非清标志位 —— 老一代用引用比较就能判断"已放行"
}

// 打破当前代: broken 置位 + 复位 + 唤醒所有人(醒来后各自抛 BrokenBarrierException)
private void breakBarrier() {
    generation.broken = true;
    count = parties;
    trip.signalAll();
}

private int dowait(boolean timed, long nanos)
    throws InterruptedException, BrokenBarrierException,
           TimeoutException {
    final ReentrantLock lock = this.lock;
    lock.lock();                                // 全程持锁, --count 和后续决策天然原子, 不需要任何 CAS
    try {
        final Generation g = generation;        // 先把"我这一代"存进局部变量, 之后判断换代全靠它

        if (g.broken)
            throw new BrokenBarrierException(); // 别人已经打破本代, 直接失败

        if (Thread.interrupted()) {             // 带着中断标记进门: 自己打破本代, 连累所有等待者
            breakBarrier();
            throw new InterruptedException();
        }

        int index = --count;
        if (index == 0) {  // 我是最后一个到达者 -> 触发放行
            Runnable command = barrierCommand;
            if (command != null) {
                try {
                    command.run();              // 回调在最后到达的线程上、放行前同步执行
                } catch (Throwable ex) {
                    breakBarrier();             // 回调抛异常必须打破整代, 否则其余线程永远等不到 signalAll
                    throw ex;
                }
            }
            nextGeneration();
            return 0;                           // 最后到达者的名次固定是 0
        }

        // 不是最后一个: 循环等待, 出口只有四个 —— 放行 / 被打破 / 中断 / 超时
        for (;;) {
            try {
                if (!timed)
                    trip.await();
                else if (nanos > 0L)
                    nanos = trip.awaitNanos(nanos);     // 返回剩余时间, 虚假唤醒再等时不会重置超时
            } catch (InterruptedException ie) {
                if (g == generation && ! g.broken) {
                    breakBarrier();             // 本代还活着时被中断: 我负责打破它再抛
                    throw ie;
                } else {
                    // 本代其实已结束(换代或已 broken), 这个中断被认定"属于后续代码":
                    // 补一个中断标记后继续走正常出口, 不在这里抛 InterruptedException
                    Thread.currentThread().interrupt();
                }
            }

            if (g.broken)
                throw new BrokenBarrierException();

            if (g != generation)                // 换代了 = 本代正常放行; index 是到达名次(N-1 最早, 1 倒数第二)
                return index;

            if (timed && nanos <= 0L) {
                breakBarrier();                 // 超时不是自己悄悄退出, 而是打破整代
                throw new TimeoutException();
            }
        }
    } finally {
        lock.unlock();
    }
}

// 基于 JDK 17, java.util.concurrent.CyclicBarrier
public int await() throws InterruptedException, BrokenBarrierException {
    try {
        return dowait(false, 0L);
    } catch (TimeoutException toe) {
        throw new Error(toe);   // 不带超时的等待不可能抛 TimeoutException, 走到这说明 JDK 自身有 bug
    }
}

public int await(long timeout, TimeUnit unit)
    throws InterruptedException,
           BrokenBarrierException,
           TimeoutException {
    return dowait(true, unit.toNanos(timeout));
}

// reset = 打破旧代 + 立即开新代: 正在等待的线程全部抛 BrokenBarrierException
public void reset() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        breakBarrier();
        nextGeneration();
    } finally {
        lock.unlock();
    }
}

public int getNumberWaiting() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        return parties - count;     // 读也要加锁: count 不是 volatile, 可见性全靠这把锁
    } finally {
        lock.unlock();
    }
}