怎么使用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. 異?；謴?/strong>：處理異常后調用reset()重置屏障
4. 回調操作：barrierAction應保持輕量，避免長時間運行
5. 資源清理：確保所有線程都能正常到達屏障，防止線程泄漏

System.out.println("等待線程數: " + barrier.getNumberWaiting());
System.out.println("屏障是否損壞: " + barrier.isBroken());