怎么使用CyclicBarrier

# 怎么使用CyclicBarrier

## 一、什么是CyclicBarrier

`CyclicBarrier`是Java并发包(`java.util.concurrent`)中提供的一个同步辅助类，它允许一组线程互相等待，直到所有线程都到达某个公共屏障点（barrier point）后再继续执行。与`CountDownLatch`类似但更强大，其名称中的"Cyclic"表示它可以被重复使用。

### 核心特点
- **多线程协同**：让多个线程在屏障处等待，直到所有线程到达后才统一释放
- **可重复使用**：通过`reset()`方法重置计数器
- **可选回调**：当所有线程到达屏障时可触发一个Runnable任务

## 二、CyclicBarrier的基本用法

### 1. 构造方法
```java
// 指定参与线程数和屏障触发时的回调
CyclicBarrier(int parties, Runnable barrierAction)

// 仅指定参与线程数
CyclicBarrier(int parties)

2. 主要方法

3. 基础示例

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        final int THREAD_COUNT = 3;
        CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT, () -> {
            System.out.println("所有线程已到达屏障");
        });
        
        for (int i = 0; i < THREAD_COUNT; i++) {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + " 开始执行");
                    Thread.sleep((long)(Math.random() * 3000));
                    System.out.println(Thread.currentThread().getName() + " 到达屏障");
                    barrier.await();
                    System.out.println(Thread.currentThread().getName() + " 继续执行");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

三、高级使用场景

1. 多阶段任务处理

// 模拟多阶段数据处理
class MultiPhaseTask {
    static final int PHASES = 3;
    static final int WORKERS = 4;
    
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(WORKERS, 
            () -> System.out.println("---阶段完成---"));
            
        for (int i = 0; i < WORKERS; i++) {
            new Thread(() -> {
                for (int phase = 1; phase <= PHASES; phase++) {
                    doWork(phase);
                    try {
                        barrier.await();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
    
    static void doWork(int phase) {
        System.out.println(Thread.currentThread().getName() 
            + " 正在执行阶段" + phase);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

2. 并行计算合并结果

class ParallelCalculation {
    static final int SEGMENTS = 5;
    static int[] partialResults = new int[SEGMENTS];
    
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(SEGMENTS, () -> {
            int total = 0;
            for (int num : partialResults) {
                total += num;
            }
            System.out.println("最终计算结果: " + total);
        });
        
        for (int i = 0; i < SEGMENTS; i++) {
            final int segment = i;
            new Thread(() -> {
                partialResults[segment] = computeSegment(segment);
                try {
                    barrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
    
    static int computeSegment(int segment) {
        // 模拟计算
        return segment * 10;
    }
}

四、异常处理机制

1. 中断处理

当等待线程被中断时： - 所有等待线程会收到BrokenBarrierException - 屏障进入”broken”状态

try {
    barrier.await();
} catch (BrokenBarrierException e) {
    System.out.println("屏障被破坏");
} catch (InterruptedException e) {
    System.out.println("线程被中断");
}

2. 超时处理

try {
    barrier.await(2, TimeUnit.SECONDS);
} catch (TimeoutException e) {
    System.out.println("等待超时");
    barrier.reset(); // 需要手动重置
}

五、与CountDownLatch的对比

六、最佳实践

1. 合理设置线程数：构造时指定的parties数应与实际参与线程数一致
2. 避免长时间阻塞：建议使用带超时的await方法
3. 异常恢复：处理异常后调用reset()重置屏障
4. 回调操作：barrierAction应保持轻量，避免长时间运行
5. 资源清理：确保所有线程都能正常到达屏障，防止线程泄漏

七、常见问题解答

Q1: 为什么我的线程在await()后没有继续执行？ A: 可能原因： - 参与的线程数不足构造时指定的parties数 - 某个线程抛出了异常未处理 - 屏障被reset()但未重新开始

Q2: 如何调试CyclicBarrier问题？ A: 可以使用以下方法检查状态：

System.out.println("等待线程数: " + barrier.getNumberWaiting());
System.out.println("屏障是否损坏: " + barrier.isBroken());

Q3: CyclicBarrier适用于什么场景？ A: 典型场景包括： - 多线程数据分片处理 - 并行计算结果汇总 - 多阶段任务协同 - 模拟压力测试

结语

CyclicBarrier是Java并发编程中强大的同步工具，特别适合需要多线程分阶段协同的场景。正确使用它可以简化复杂的线程协调逻辑，但需要注意异常处理和资源管理。结合具体业务需求，合理选择同步工具，才能构建出高效可靠的并发程序。 “`

注：本文实际约1600字，包含了CyclicBarrier的核心概念、基础用法、高级示例、异常处理、对比分析和实践建议，采用Markdown格式编写，可直接用于技术文档或博客发布。