CyclicBarrier的await()方法底层原理

一、定义

CyclicBarrier 的 await() 方法是其核心功能之一，用于让线程在屏障点等待，直到所有参与的线程都到达屏障后，才能继续执行。

其底层实现依赖于 AQS（AbstractQueuedSynchronizer）和 ReentrantLock，以下是 await() 方法的底层原理的详细解析

二、CyclicBarrier 的核心依赖

CyclicBarrier 的底层实现基于以下两个核心组件：

1、ReentrantLock：

用于保护共享资源的访问，确保线程安全

2、Condition：

用于线程的等待和唤醒。

CyclicBarrier 内部维护了一个计数器（count），表示尚未到达屏障的线程数。当计数器减至 0 时，屏障被触发，所有等待的线程被唤醒。

三、await() 方法的工作流程

当线程调用 await() 方法时，底层逻辑如下：

(1) 检查屏障是否已破坏

如果屏障已被破坏（如调用了 reset() 或线程被中断），则抛出 BrokenBarrierException

(2) 减少计数器

使用 ReentrantLock 加锁，确保线程安全。
将计数器 count 减 1。
如果 count 减至 0，表示所有线程都已到达屏障，执行以下操作：
- a、执行预定义的 Runnable 任务（如果有）。
- b、唤醒所有等待的线程。
- c、重置计数器为初始值（parties），以便屏障可以重复使用。

(3) 线程等待

如果 count 未减至 0，线程调用 Condition.await() 进入等待状态。
线程被挂起，直到以下条件之一满足：
- a、其他线程调用 await() 将 count 减至 0，触发屏障。
- b、线程被中断（抛出 InterruptedException）
- c、屏障被破坏（抛出 BrokenBarrierException）

(4) 返回线程到达屏障的顺序索引

当线程被唤醒后，await() 方法返回一个整数，表示线程到达屏障的顺序索引（从 0 到 parties-1）

四、以下是 await() 方法的简化代码逻辑

1、CyclicBarrier.await()

2、CyclicBarrier.dowait()

  // timed：表示当前调用await方法的线程是否指定了超时时长，如果 true 表示线程是响应超时的
  // nanos：线程等待超时时长，单位是纳秒
private int dowait(boolean timed, long nanos) {
    final ReentrantLock lock = this.lock;
    // 加锁
    lock.lock();
    try {
        // 获取当前代
        final Generation g = generation;

        // 【如果当前代是已经被打破状态，则当前调用await方法的线程，直接抛出Broken异常】
        if (g.broken)
            throw new BrokenBarrierException();
		// 如果当前线程被中断了，则打破当前代，然后当前线程抛出中断异常
        if (Thread.interrupted()) {
            // 设置当前代的状态为 broken 状态，唤醒在 trip 条件队列内的线程
            breakBarrier();
            throw new InterruptedException();
        }

        // 逻辑到这说明，当前线程中断状态是 false， 当前代的 broken 为 false（未打破状态）
        
        // 假设 parties 给的是 5，那么index对应的值为 4,3,2,1,0
        int index = --count;
        // 条件成立说明当前线程是最后一个到达 barrier 的线程，【需要开启新代，唤醒阻塞线程】
        if (index == 0) {
            // 栅栏任务启动标记
            boolean ranAction = false;
            try {
                final Runnable command = barrierCommand;
                if (command != null)
                    // 启动触发的任务
                    command.run();
                // run()未抛出异常的话，启动标记设置为 true
                ranAction = true;
                // 重置屏障，这里会【唤醒所有的阻塞队列】
                nextGeneration();
                // 返回 0 因为当前线程是此代最后一个到达的线程，index == 0
                return 0;
            } finally {
                // 如果 command.run() 执行抛出异常的话，会进入到这里
                if (!ranAction)
                    breakBarrier();
            }
        }

        // 自旋，一直到条件满足、当前代被打破、线程被中断，等待超时
        for (;;) {
            try {
                // 根据是否需要超时等待选择阻塞方法
                if (!timed)
                    // 当前线程释放掉 lock，【进入到 trip 条件队列的尾部挂起自己】，等待被唤醒
                    trip.await();
                else if (nanos > 0L)
                    nanos = trip.awaitNanos(nanos);
            } catch (InterruptedException ie) {
                // 被中断后来到这里的逻辑
                
                // 当前代没有变化并且没有被打破
                if (g == generation && !g.broken) {
                    // 打破屏障
                    breakBarrier();
                    // node 节点在【条件队列】内收到中断信号时 会抛出中断异常
                    throw ie;
                } else {
                    // 等待过程中代变化了，完成一次自我打断
                    Thread.currentThread().interrupt();
                }
            }
			// 唤醒后的线程，【判断当前代已经被打破，线程唤醒后依次抛出 BrokenBarrier 异常】
            if (g.broken)
                throw new BrokenBarrierException();

            // 当前线程挂起期间，最后一个线程到位了，然后触发了开启新的一代的逻辑
            if (g != generation)
                return index;
			// 当前线程 trip 中等待超时，然后主动转移到阻塞队列
            if (timed && nanos <= 0L) {
                breakBarrier();
                // 抛出超时异常
                throw new TimeoutException();
            }
        }
    } finally {
        // 解锁
        lock.unlock();
    }
}

3、CyclicBarrier.nextGeneration()