深入解析CyclicBarrier与CountDownLatch：Java并发同步工具的双子星

本文链接：https://blog.youkuaiyun.com/weixin_44186453/article/details/147013280

一、同步工具概述

在Java并发编程中，CyclicBarrier和CountDownLatch是两大核心同步工具类，它们虽然功能相似但设计理念和使用场景却大不相同。理解它们的差异对于编写高效并发程序至关重要。

1.1 同步工具对比矩阵

特性	CyclicBarrier	CountDownLatch
重置能力	可循环使用	一次性使用
计数方向	递增到指定值	递减到零
等待机制	线程互相等待	线程等待计数器归零
触发动作	可设置回调函数	无回调功能
典型应用场景	多阶段并行计算	主线程等待多个子任务完成

二、CountDownLatch深度解析

2.1 核心机制

CountDownLatch是一种"发令枪"模式的实现，允许一个或多个线程等待其他线程完成操作。

// 典型用法示例
CountDownLatch latch = new CountDownLatch(3);

// 工作线程
Runnable worker = () -> {
    doWork();
    latch.countDown(); // 计数器减1
};

// 启动多个工作线程
new Thread(worker).start();
new Thread(worker).start();
new Thread(worker).start();

// 主线程等待所有工作完成
latch.await();
System.out.println("All workers completed");

2.2 实现原理

内部类Sync继承自AQS：

状态state表示计数器值
countDown()调用releaseShared(1)
await()调用acquireSharedInterruptibly(1)

2.3 典型应用场景

服务启动依赖检查：

// 确保所有服务就绪后再启动主服务
CountDownLatch readinessLatch = new CountDownLatch(serviceCount);
for (Service service : services) {
    new Thread(() -> {
        service.start();
        readinessLatch.countDown();
    }).start();
}
readinessLatch.await();

并行任务聚合：

// 并行计算后汇总结果
List<Result> results = Collections.synchronizedList(new ArrayList<>());
CountDownLatch doneLatch = new CountDownLatch(taskCount);
for (Task task : tasks) {
    executor.execute(() -> {
        results.add(compute(task));
        doneLatch.countDown();
    });
}
doneLatch.await();
process(results);

三、CyclicBarrier深度解析

3.1 核心机制

CyclicBarrier实现了一种"集合点"模式，让一组线程互相等待，直到所有线程都到达某个执行点。

// 典型用法示例
CyclicBarrier barrier = new CyclicBarrier(3, 
    () -> System.out.println("All threads reached barrier"));

Runnable task = () -> {
    phaseOne();
    barrier.await();  // 第一集合点
    phaseTwo();
    barrier.await();  // 第二集合点
};

IntStream.range(0,3).forEach(i -> new Thread(task).start());

3.2 实现原理

基于ReentrantLock和Condition实现：

Generation对象记录当前代次
await()触发条件等待或换代逻辑
损坏处理机制（BrokenBarrierException）

3.3 典型应用场景

并行迭代计算：

// 并行矩阵计算
double[][] matrix = ...;
CyclicBarrier barrier = new CyclicBarrier(N, 
    () -> mergePartialResults());

for (int i = 0; i < N; i++) {
    final int row = i;
    executor.execute(() -> {
        while (!converged()) {
            computeRow(matrix, row);
            barrier.await();
        }
    });
}

多阶段测试：

// 并发压力测试
CyclicBarrier testBarrier = new CyclicBarrier(userCount + 1); // +1 for main

for (int i = 0; i < userCount; i++) {
    new Thread(() -> {
        testBarrier.await(); // 准备阶段
        doTestAction();
        testBarrier.await(); // 结束阶段
    }).start();
}

testBarrier.await(); // 等待所有准备完成
testBarrier.await(); // 等待所有测试完成

四、对比分析与选型指南

4.1 本质区别

CountDownLatch：

事件驱动的等待机制
计数器由外部线程控制
不可重置的同步点

CyclicBarrier：

线程自主的同步机制
计数器由等待线程自身控制
可重复使用的同步屏障

4.2 选型决策树

4.3 性能考量

CountDownLatch：
- 基于AQS，适合一次性等待场景
- 最小化同步开销
CyclicBarrier：
- 基于重入锁，适合复杂同步逻辑
- 每代次有额外创建开销

五、高级模式与陷阱规避

5.1 组合使用模式

// 启动多个服务并等待就绪后执行周期性任务
CountDownLatch startupLatch = new CountDownLatch(serviceCount);
CyclicBarrier taskBarrier = new CyclicBarrier(serviceCount);

for (Service service : services) {
    executor.execute(() -> {
        service.start();
        startupLatch.countDown();
        
        startupLatch.await(); // 等待所有服务启动
        while (running) {
            service.executeTask();
            taskBarrier.await(); // 同步任务周期
        }
    });
}

5.2 常见陷阱与解决方案

问题1：线程永久阻塞

原因：等待线程数不足导致屏障无法打破
方案：设置超时await(timeout, unit)

问题2：屏障损坏

原因：等待线程被中断或超时
方案：捕获BrokenBarrierException并重置

try {
    barrier.await();
} catch (BrokenBarrierException e) {
    barrier.reset(); // 重置屏障
    // 处理异常
}

问题3：误用导致性能下降

原因：在低冲突场景使用CyclicBarrier
方案：评估是否需要线程间同步

六、演进与替代方案

6.1 Phaser：更灵活的屏障

Java 7引入的Phaser结合了两者优点：

动态注册/注销参与线程
支持分层结构
可定制的到达逻辑

Phaser phaser = new Phaser(3); // 初始3个注册方

// 动态注册新参与者
phaser.register(); 

// 到达并等待
int phase = phaser.arriveAndAwaitAdvance();

七、最佳实践总结

CountDownLatch适用场景：
- 主线程等待多个子任务初始化完成
- 多个线程等待某个"开始信号"
- 最大并行度的控制
CyclicBarrier适用场景：
- 并行计算的多阶段同步
- 迭代算法的并行执行
- 需要重复同步的测试场景
通用原则：
- 优先选择更简单的同步工具
- 明确同步需求的性质（事件等待 vs 线程协作）
- 考虑超时处理以避免死锁
- 在复杂场景评估Phaser的适用性