松林AI说头像
Java 24 并发中的 CyclicBarrier 源码:可重用同步屏障的循环等待机制封面图

Java 24 并发中的 CyclicBarrier 源码:可重用同步屏障的循环等待机制

封面信息图

在 Java 并发工具箱(java.util.concurrent)中,CountDownLatch 与 CyclicBarrier 经常被放在一起比较。但两者的核心建模思想截然不同:CountDownLatch 是一个一次性的倒计数门闩,一旦计数归零便彻底失效;而 CyclicBarrier(循环屏障)则是一个可重用的多线程会合点。它允许多个工作线程在某个计算阶段相互等待,当所有线程都到达屏障后,可触发一个可选的屏障动作(Barrier Action),随后自动重置,无缝进入下一轮迭代。

在 Java 24 环境下,随着虚拟线程(Virtual Threads)的完全成熟与 JUC 锁机制的持续优化,理解 CyclicBarrier 底层如何通过 ReentrantLock、Condition 以及“代(Generation)”状态机实现严格的同步协同,对于构建高性能并行计算流水线至关重要。


一、 核心架构设计:为什么不用 AQS 共享锁?

阅读源码前,很多开发者会产生一个疑问:CountDownLatch 和 Semaphore 都是基于 AbstractQueuedSynchronizer(AQS)的共享模式(Shared Mode)直接实现的,为什么 CyclicBarrier 却没有直接继承或封装 AQS,而是内部组合了一个 ReentrantLock 和一个 Condition?

其根本原因在于 “换代(Generation)”与“级联破损(Broken Barrier)”的强一致性需求:

  1. 屏障动作的排他性执行:当最后一个线程到达时,屏障可能需要执行一段回调代码(barrierCommand),必须保证在此回调执行完毕前,其他等待线程绝对不能提前唤醒进入下一阶段;
  2. 异常级联响应:若等待队列中有任意一个线程遭遇中断(InterruptedException)或超时(TimeoutException),整个屏障必须立即宣告“破损(Broken)”,并能够原子性地唤醒所有在此停滞的线程,全部抛出 BrokenBarrierException,避免系统进入部分活跃、部分死锁的半瘫痪状态;
  3. 采用显式锁配合条件队列,能够将复杂的换代状态机封装在一个严密的互斥临界区内,逻辑比纯 AQS 共享状态回滚更加清晰稳固。

二、 源码核心成员与“代”的生命周期

在 JDK 24 的 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;
    /** 当前代(Generation)标识 */
    private Generation generation = new Generation();

    /** 剩余需要到达屏障的线程计数,每代初始化为 parties */
    private int count;

    /**
     * 每一代屏障的独立载体。
     * 只要屏障被打破,broken 设为 true。
     */
    private static class Generation {
        boolean broken; // 默认为 false
    }
}

“代(Generation)”是 CyclicBarrier 实现可重用性的灵魂设计。每当一组线程完整跨越屏障,或者调用 reset() 重置时,系统都会丢弃旧的 generation 对象,并实例化一个新的 Generation。挂在旧代条件队列中的线程一旦被唤醒,首先通过对比代标识即可判断自己是正常通关还是异常唤醒。


三、 dowait 核心流程全链路剖析

线程调用 await() 最终都会委托给私有方法 dowait(boolean timed, long nanos)。这是整个并发工具最核心的逻辑枢纽:

private int dowait(boolean timed, long nanos)
    throws InterruptedException, BrokenBarrierException,
           TimeoutException {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        final Generation g = generation;

        // 1. 屏障已破损,直接拒绝服务
        if (g.broken)
            throw new BrokenBarrierException();

        // 2. 检查当前线程中断状态
        if (Thread.interrupted()) {
            breakBarrier(); // 打破屏障并唤醒其他所有等待者
            throw new InterruptedException();
        }

        // 3. 递减计数
        int index = --count;

        // 4. 最后一个到达屏障的线程(触发通关)
        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(); // 若回调函数抛出异常,必须打破屏障
            }
        }

        // 5. 非最后一个线程:进入自旋/挂起循环
        for (;;) {
            try {
                if (!timed)
                    trip.await(); // 无限期挂起在 Condition 上
                else if (nanos > 0L)
                    nanos = trip.awaitNanos(nanos); // 超时等待
            } catch (InterruptedException ie) {
                // 等待期间被外部打断
                if (g == generation && !g.broken) {
                    breakBarrier();
                    throw ie;
                } else {
                    // 若被打断时正好发生了换代,补偿中断标记
                    Thread.currentThread().interrupt();
                }
            }

            // 6. 从挂起中唤醒后的校验
            if (g.broken)
                throw new BrokenBarrierException();

            // 如果已经换代,说明大家都到了,成功通关!
            if (g != generation)
                return index;

            // 超时处理
            if (timed && nanos <= 0L) {
                breakBarrier();
                throw new TimeoutException();
            }
        }
    } finally {
        lock.unlock();
    }
}
关键机制拆解:
  1. nextGeneration() 如何平滑换代?

    private void nextGeneration() {
        trip.signalAll(); // 广播唤醒当前 Condition 队列上的所有线程
        count = parties;  // 恢复计数
        generation = new Generation(); // 赋予全新的代引用
    }
    

    注意唤醒与引用的顺序:先执行 signalAll(),将等待队列里的节点转移到 AQS 的同步等待队列,再分配新的 Generation。挂起线程醒来后,检测到 g != generation,立即安全退出 dowait,不会再误陷入下一次循环。

  2. breakBarrier() 的级联风暴

    private void breakBarrier() {
        generation.broken = true;
        count = parties;
        trip.signalAll();
    }
    

    只要有一个线程在等待时超时、被 interrupt、或者 barrierCommand.run() 发生运行时异常,该方法就会被触发。所有沉睡在 trip 上的兄弟线程都会被统一叫醒,并在检测到 g.broken == true 时一并抛出 BrokenBarrierException。这彻底杜绝了某个线程异常退出而其他线程无限死等的严重并发隐患。


四、 生产实战:多阶段数据处理流水线

以下代码演示了利用 CyclicBarrier 实现一个三阶段并行的批量数据计算管道:

import java.util.concurrent.*;

public class CyclicBarrierPipelineDemo {
    private static final int PARTIES = 3;
    private static final int ROUNDS = 2;

    public static void main(String[] args) {
        // 创建屏障,每轮所有人到达后打印汇总动作
        CyclicBarrier barrier = new CyclicBarrier(PARTIES, new Runnable() {
            private int step = 1;
            @Override
            public void run() {
                System.out.printf("=== 第 %d 阶段协同完成,执行系统检查点 ===\n", step++);
            }
        });

        try (var executor = Executors.newFixedThreadPool(PARTIES)) {
            for (int i = 0; i < PARTIES; i++) {
                final int workerId = i;
                executor.submit(() -> {
                    try {
                        for (int round = 1; round <= ROUNDS; round++) {
                            // 模拟数据运算
                            long workTime = (long) (Math.random() * 500 + 200);
                            Thread.sleep(workTime);
                            System.out.printf("[Worker-%d] 完成第 %d 阶段运算,耗时 %d ms,等待屏障...\n",
                                    workerId, round, workTime);

                            // 达到屏障,挂起等待其他同伴
                            barrier.await();

                            // 跨越屏障后的下一阶段逻辑
                            System.out.printf("[Worker-%d] 跨越屏障,进入后续流程。\n", workerId);
                        }
                    } catch (InterruptedException | BrokenBarrierException e) {
                        System.err.printf("[Worker-%d] 遇到异常退出: %s\n", workerId, e.getMessage());
                    }
                });
            }
        }
    }
}

五、 虚拟线程时代对 CyclicBarrier 的影响

在 Java 21/24 中,大量开发者使用虚拟线程替代平台线程。在将 CyclicBarrier 应用于虚拟线程时,需要明确其底层行为:

  • CyclicBarrier 使用的是 ReentrantLock 和 Condition,其挂起操作通过 LockSupport.park 实现。
  • 在现代 JVM 中,虚拟线程在 LockSupport.park 处不会锁定底层的操作系统载体线程(Carrier Thread),而是会将虚拟线程的状态卸载并挂起,让出载体线程给其他虚拟任务运行。
  • 因此,在需要协同数千个高并发批处理虚拟任务时,CyclicBarrier 依旧表现得非常轻量与安全,不会发生传统平台线程容易出现的线程池耗尽(Thread Starvation)问题。

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/cannonjinx/article/details/167701966

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--