Java中CyclicBarrier的使用方法

# Java中CyclicBarrier的使用方法

## 一、CyclicBarrier概述

CyclicBarrier是Java并发包(`java.util.concurrent`)中提供的一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点（Common Barrier Point）。与CountDownLatch不同，CyclicBarrier具有以下特点：

1. **可重用性**：屏障可以重复使用（通过`reset()`方法）
2. **回调机制**：支持在所有线程到达屏障后执行特定操作（通过`Runnable`参数）
3. **线程阻塞**：到达屏障的线程会被阻塞，直到最后一个线程到达

## 二、核心方法说明

| 方法 | 描述 |
|------|------|
| `CyclicBarrier(int parties)` | 创建指定参与线程数的屏障 |
| `CyclicBarrier(int parties, Runnable barrierAction)` | 创建屏障并指定到达后执行的操作 |
| `await()` | 线程等待直到所有线程都调用此方法 |
| `await(long timeout, TimeUnit unit)` | 带超时的等待 |
| `getNumberWaiting()` | 返回当前在屏障处等待的线程数 |
| `getParties()` | 返回需要的线程数 |
| `reset()` | 重置屏障到初始状态 |

## 三、基础使用示例

### 3.1 基本用法
```java
public class BasicExample {
    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();
        }
    }
}

3.2 输出结果示例

Thread-0 开始执行
Thread-1 开始执行
Thread-2 开始执行
Thread-1 到达屏障
Thread-0 到达屏障
Thread-2 到达屏障
所有线程已到达屏障
Thread-2 继续执行
Thread-0 继续执行
Thread-1 继续执行

四、高级应用场景

4.1 多阶段任务处理

public class MultiPhaseTask {
    public static void main(String[] args) {
        final int PHASE_COUNT = 3;
        CyclicBarrier barrier = new CyclicBarrier(4); // 3工作线程+1主线程
        
        for (int phase = 1; phase <= PHASE_COUNT; phase++) {
            System.out.println("===== 阶段" + phase + "开始 =====");
            
            for (int i = 0; i < 3; i++) {
                new WorkerThread(barrier, "Worker-"+i, phase).start();
            }
            
            try {
                barrier.await(); // 主线程等待
                System.out.println("===== 阶段" + phase + "完成 =====");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

class WorkerThread extends Thread {
    private CyclicBarrier barrier;
    private int phase;
    
    public WorkerThread(CyclicBarrier barrier, String name, int phase) {
        super(name);
        this.barrier = barrier;
        this.phase = phase;
    }
    
    @Override
    public void run() {
        try {
            System.out.println(getName() + " 正在执行阶段" + phase + "任务");
            Thread.sleep(1000 + (long)(Math.random() * 2000));
            System.out.println(getName() + " 完成阶段" + phase + "任务");
            barrier.await();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4.2 异常处理机制

当线程在等待时被中断或发生超时，会抛出： - InterruptedException：线程被中断 - BrokenBarrierException：其他线程被中断或超时导致屏障损坏 - TimeoutException：等待超时

try {
    barrier.await(2, TimeUnit.SECONDS);
} catch (TimeoutException e) {
    System.out.println("等待超时");
    barrier.reset(); // 重置屏障
} catch (BrokenBarrierException e) {
    System.out.println("屏障已损坏");
}

五、与CountDownLatch的对比

六、最佳实践建议

1. 合理设置线程数：parties值应与实际工作线程数一致
2. 避免长时间阻塞：建议使用带超时的await()方法
3. 屏障重置注意事项：调用reset()时确保没有线程正在等待
4. 异常处理：妥善处理可能的中断和超时情况
5. 回调操作优化：屏障操作应尽量轻量，避免长时间任务

七、总结

CyclicBarrier是处理多线程协同工作的强大工具，特别适用于需要分阶段执行的并行任务场景。通过合理使用可重用特性和回调机制，可以构建高效的线程协作模型。实际开发中需要根据具体需求选择同步工具，对于需要循环使用的多线程等待场景，CyclicBarrier是最佳选择。 “`

（注：实际字数约1150字，具体字数可能因格式调整略有变化）