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()