public class CyclicBarrier {}
```　　

### 類的內(nèi)部類

CyclicBarrier類存在一個內(nèi)部類Generation，每一次使用的CycBarrier可以當成Generation的實例，其源代碼如下

```java
private static class Generation {
boolean broken = false;
}

public class CyclicBarrier {

/** The lock for guarding barrier entry */
// 可重入鎖
private final ReentrantLock lock = new ReentrantLock();
/** Condition to wait on until tripped */
// 條件隊列
private final Condition trip = lock.newCondition();
/** The number of parties */
// 參與的線程數(shù)量
private final int parties;
/* The command to run when tripped */
// 由最后一個進入 barrier 的線程執(zhí)行的操作
private final Runnable barrierCommand;
/** The current generation */
// 當前代
private Generation generation = new Generation();
// 正在等待進入屏障的線程數(shù)量
private int count;
}

public CyclicBarrier(int parties, Runnable barrierAction) {
// 參與的線程數(shù)量小于等于0，拋出異常
if (parties <= 0) throw new IllegalArgumentException();
// 設(shè)置parties
this.parties = parties;
// 設(shè)置count
this.count = parties;
// 設(shè)置barrierCommand
this.barrierCommand = barrierAction;
}

public CyclicBarrier(int parties) {
// 調(diào)用含有兩個參數(shù)的構(gòu)造函數(shù)
this(parties, null);
}

private int dowait(boolean timed, long nanos)
throws InterruptedException, BrokenBarrierException,
TimeoutException {
// 保存當前鎖
final ReentrantLock lock = this.lock;
// 鎖定
lock.lock();
try {
// 保存當前代
final Generation g = generation;

if (g.broken) // 屏障被破壞，拋出異常
throw new BrokenBarrierException();

if (Thread.interrupted()) { // 線程被中斷
// 損壞當前屏障，并且喚醒所有的線程，只有擁有鎖的時候才會調(diào)用
breakBarrier();
// 拋出異常
throw new InterruptedException();
}

// 減少正在等待進入屏障的線程數(shù)量
int index = --count;
if (index == 0) { // 正在等待進入屏障的線程數(shù)量為0，所有線程都已經(jīng)進入
// 運行的動作標識
boolean ranAction = false;
try {
// 保存運行動作
final Runnable command = barrierCommand;
if (command != null) // 動作不為空
// 運行
command.run();
// 設(shè)置ranAction狀態(tài)
ranAction = true;
// 進入下一代
nextGeneration();
return 0;
} finally {
if (!ranAction) // 沒有運行的動作
// 損壞當前屏障
breakBarrier();
}
}

// loop until tripped, broken, interrupted, or timed out
// 無限循環(huán)
for (;;) {
try {
if (!timed) // 沒有設(shè)置等待時間
// 等待
trip.await();
else if (nanos > 0L) // 設(shè)置了等待時間，并且等待時間大于0
// 等待指定時長
nanos = trip.awaitNanos(nanos);
} catch (InterruptedException ie) {
if (g == generation && ! g.broken) { // 等于當前代并且屏障沒有被損壞
// 損壞當前屏障
breakBarrier();
// 拋出異常
throw ie;
} else { // 不等于當前帶后者是屏障被損壞
// We're about to finish waiting even if we had not
// been interrupted, so this interrupt is deemed to
// "belong" to subsequent execution.
// 中斷當前線程
Thread.currentThread().interrupt();
}
}

if (g.broken) // 屏障被損壞，拋出異常
throw new BrokenBarrierException();

if (g != generation) // 不等于當前代
// 返回索引
return index;

if (timed && nanos <= 0L) { // 設(shè)置了等待時間，并且等待時間小于0
// 損壞屏障
breakBarrier();
// 拋出異常
throw new TimeoutException();
}
}
} finally {
// 釋放鎖
lock.unlock();
}
}

private void nextGeneration() {
// signal completion of last generation
// 喚醒所有線程
trip.signalAll();
// set up next generation
// 恢復(fù)正在等待進入屏障的線程數(shù)量
count = parties;
// 新生一代
generation = new Generation();
}

public final void signalAll() {
if (!isHeldExclusively()) // 不被當前線程獨占，拋出異常
throw new IllegalMonitorStateException();
// 保存condition隊列頭節(jié)點
Node first = firstWaiter;
if (first != null) // 頭節(jié)點不為空
// 喚醒所有等待線程
doSignalAll(first);
}