public class CyclicBarrier {}
```　　

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

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

```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 */
// 條件隊(duì)列
private final Condition trip = lock.newCondition();
/** The number of parties */
// 參與的線程數(shù)量
private final int parties;
/* The command to run when tripped */
// 由最后一個(gè)進(jìn)入 barrier 的線程執(zhí)行的操作
private final Runnable barrierCommand;
/** The current generation */
// 當(dāng)前代
private Generation generation = new Generation();
// 正在等待進(jìn)入屏障的線程數(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)用含有兩個(gè)參數(shù)的構(gòu)造函數(shù)
this(parties, null);
}

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

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

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

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

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

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

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

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

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

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