// java.util.concurrent.CyclicBarrier
public class CyclicBarrier {

    private final ReentrantLock lock = new ReentrantLock();   // ① 锁
    private final Condition trip = lock.newCondition();       // ② 条件队列
    private final int parties;                                // ③ 参与方总数
    private final Runnable barrierCommand;                    // ④ 屏障动作
    private Generation generation = new Generation();         // ⑤ 当前代际
    private int count;                                        // ⑥ 倒计数

    // 内部类——代际
    private static class Generation {
        Generation() {}          // 默认 broken = false
        boolean broken;          // 当前代是否被打破
    }
}

private static class Generation {
    boolean broken;  // false=本轮正常，true=本轮已打破
}

// 无限等待——直到所有线程到达或被打断
public int await() throws InterruptedException, BrokenBarrierException {
    try {
        return dowait(false, 0L);  // timed=false, 不超时
    } catch (TimeoutException e) {
        throw new Error(e);         // 不可能发生（timed=false 不会超时）
    }
}

// 限时等待——超时会打破屏障
public int await(long timeout, TimeUnit unit)
        throws InterruptedException, BrokenBarrierException, TimeoutException {
    return dowait(true, unit.toNanos(timeout));  // timed=true
}

// java.util.concurrent.CyclicBarrier.dowait()
private int dowait(boolean timed, long nanos)
        throws InterruptedException, BrokenBarrierException, TimeoutException {

    final ReentrantLock lock = this.lock;
    lock.lock();                                       // ① 获取锁
    try {
        final Generation g = generation;               // ② 记住当前代际

        // ③ 先检查：当前代是否已经被打破？
        if (g.broken)
            throw new BrokenBarrierException();

        // ④ 再检查：当前线程是否被中断？
        if (Thread.interrupted()) {
            breakBarrier();                            // 打破屏障
            throw new InterruptedException();
        }

        // ⑤ 倒计数减1
        int index = --count;

        // ⑥ 判断：是否是最后一个到达的线程？
        if (index == 0) {                              // 所有线程到齐！
            boolean ranAction = false;
            try {
                final Runnable command = barrierCommand;
                if (command != null)
                    command.run();                     // 执行屏障动作
                ranAction = true;
                nextGeneration();                      // 进入下一代
                return 0;
            } finally {
                if (!ranAction)
                    breakBarrier();                    // 屏障动作抛异常→打破屏障
            }
        }

        // ⑦ count > 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 {
                    Thread.currentThread().interrupt(); // 已经是新代→重置中断标记
                }
            }

            // ⑨ 唤醒后检查：屏障被打破了？
            if (g.broken)
                throw new BrokenBarrierException();

            // ⑩ 唤醒后检查：已经是新代了？
            if (g != generation)
                return index;                          // 正常返回

            // ⑪ 超时处理
            if (timed && nanos <= 0L) {
                breakBarrier();
                throw new TimeoutException();
            }
        }
    } finally {
        lock.unlock();                                 // ⑫ 释放锁
    }
}

// 进入下一代——屏障正常打开时调用
private void nextGeneration() {
    trip.signalAll();          // 唤醒所有在 trip 上等待的线程
    count = parties;           // 重置计数器
    generation = new Generation();  // 创建新代际（broken=false）
}

// 打破屏障——发生异常时调用
private void breakBarrier() {
    generation.broken = true;  // 标记当前代已打破
    count = parties;           // 重置计数器
    trip.signalAll();          // 唤醒所有等待线程（它们醒来后会抛异常）
}

// dowait() 中 index==0 分支
final Runnable command = barrierCommand;
if (command != null)
    command.run();   // 直接调用 run()，不是 start() 或 submit()

// 验证代码
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
    System.out.println(Thread.currentThread().getName() + " 执行屏障动作");
    try { Thread.sleep(2000); } catch (InterruptedException e) {}
});

for (int i = 0; i < 3; i++) {
    new Thread(() -> {
        try {
            System.out.println(Thread.currentThread().getName() + " 到达");
            barrier.await();
            System.out.println(Thread.currentThread().getName() + " 继续");
        } catch (Exception e) {}
    }).start();
}

// 输出:
// Thread-0 到达
// Thread-1 到达
// Thread-2 到达
// Thread-2 执行屏障动作        ← 最后一个到达的线程执行
// (停顿2秒)
// Thread-0 继续               ← 其他线程等barrierCommand执行完才被唤醒
// Thread-1 继续
// Thread-2 继续

// 验证代码
CyclicBarrier barrier = new CyclicBarrier(3);

// 线程A：到达后等待
new Thread(() -> {
    try {
        barrier.await();  // 被中断，抛出 InterruptedException
    } catch (Exception e) {
        System.out.println("A: " + e.getClass().getSimpleName());
    }
}).start();

Thread.sleep(100);

// 线程B：到达后超时
new Thread(() -> {
    try {
        barrier.await(1, TimeUnit.SECONDS);  // 超时
    } catch (Exception e) {
        System.out.println("B: " + e.getClass().getSimpleName());
    }
}).start();

Thread.sleep(2000);

// 线程C：后续到达
new Thread(() -> {
    try {
        barrier.await();  // 屏障已破，直接抛异常
    } catch (Exception e) {
        System.out.println("C: " + e.getClass().getSimpleName());
    }
}).start();

// 输出:
// B: TimeoutException         ← B超时触发了breakBarrier()
// A: InterruptedException     ← A被中断(因为B的break触发了signalAll)
// C: BrokenBarrierException   ← C发现generation.broken=true

CyclicBarrier barrier = new CyclicBarrier(3, () ->
    System.out.println("=== 屏障打开 ===")
);

for (int round = 1; round <= 3; round++) {
    System.out.println("--- 第" + round + "轮 ---");
    for (int i = 0; i < 3; i++) {
        new Thread(() -> {
            try {
                Thread.sleep(ThreadLocalRandom.current().nextInt(500));
                System.out.println(Thread.currentThread().getName() + " 到达");
                barrier.await();
                System.out.println(Thread.currentThread().getName() + " 通过");
            } catch (Exception e) {}
        }).start();
    }
    Thread.sleep(3000); // 等本轮全部完成
}

// 输出:
// --- 第1轮 ---
// Thread-0 到达
// Thread-1 到达
// Thread-2 到达
// === 屏障打开 ===
// Thread-2 通过
// Thread-0 通过
// Thread-1 通过
// --- 第2轮 ---
// ...(同样模式)...

// CountDownLatch 内部依赖 AQS 的 Sync
private static final class Sync extends AbstractQueuedSynchronizer {
    Sync(int count) { setState(count); }
    int getCount()  { return getState(); }
    protected int tryAcquireShared(int acquires) {
        return (getState() == 0) ? 1 : -1;  // count==0 才成功
    }
    protected boolean tryReleaseShared(int releases) {
        for (;;) {
            int c = getState();
            if (c == 0) return false;        // 已经是0，不能再减
            int nextc = c - 1;
            if (compareAndSetState(c, nextc))
                return nextc == 0;           // 减到0时唤醒所有等待线程
        }
    }
}

// CyclicBarrier 内部使用 ReentrantLock + Condition
private final ReentrantLock lock = new ReentrantLock();
private final Condition trip = lock.newCondition();

public class PhasedCalculation {
    private static final int THREADS = 3;
    private static final ConcurrentMap<String, Integer> sharedData = new ConcurrentHashMap<>();

    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(THREADS, () -> {
            // 每阶段结束后打印当前汇总
            System.out.println("阶段完成，当前数据: " + sharedData);
        });

        for (int i = 0; i < THREADS; i++) {
            final int threadId = i;
            new Thread(() -> {
                try {
                    // 阶段一：各算各的
                    sharedData.put("t" + threadId, threadId * 10);
                    barrier.await();  // 等其他人也算完阶段一

                    // 阶段二：基于共享数据继续算
                    int sum = sharedData.values().stream().mapToInt(v -> v).sum();
                    sharedData.put("t" + threadId + "_sum", sum);
                    barrier.await();  // 等其他人也算完阶段二

                    // 阶段三：验证
                    System.out.println("线程" + threadId + " 全部完成");
                } catch (InterruptedException | BrokenBarrierException e) {
                    Thread.currentThread().interrupt();
                }
            }).start();
        }
    }
}

public class ConcurrentTest {
    private static final int THREADS = 10;

    public static void main(String[] args) throws InterruptedException {
        // 屏障动作：发令枪
        CyclicBarrier startBarrier = new CyclicBarrier(THREADS, () ->
            System.out.println("所有线程就绪，同时开始！")
        );

        for (int i = 0; i < THREADS; i++) {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + " 已就绪");
                    startBarrier.await();  // 等所有人就绪
                    // 从此处开始，所有线程几乎同时执行
                    doActualWork();
                } catch (Exception e) {
                    Thread.currentThread().interrupt();
                }
            }).start();
        }
    }
}