public class CyclicBarrierExample {
 static class PreTaskThread implements Runnable {
 private String task;
 private CyclicBarrier cyclicBarrier;

 public PreTaskThread(String task, CyclicBarrier cyclicBarrier) {
  this.task = task;
  this.cyclicBarrier = cyclicBarrier;
 }

 @Override
 public void run() {
  for (int i = 0; i < 4; i++) {
  Random random = new Random();
  try {
   Thread.sleep(random.nextInt(1000));
   System.out.println(String.format("關(guān)卡 %d 的任務(wù) %s 完成", i, task));
   cyclicBarrier.await();
  } catch (InterruptedException | BrokenBarrierException e) {
   e.printStackTrace();
  }
  }
 }

 public static void main(String[] args) {
  CyclicBarrier cyclicBarrier = new CyclicBarrier(3, () -> {
  System.out.println("本關(guān)卡所有的前置任務(wù)完成，開始游戲... ...");
  });
  new Thread(new PreTaskThread("加載地圖數(shù)據(jù)", cyclicBarrier)).start();
  new Thread(new PreTaskThread("加載人物模型", cyclicBarrier)).start();
  new Thread(new PreTaskThread("加載背景音樂", cyclicBarrier)).start();
 }
 }
}

 /** 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 */
 private final int parties;
 /* The command to run when tripped */
 private final Runnable barrierCommand;
 /** The current generation */
 private Generation generation = new Generation();

 public int await() throws InterruptedException, BrokenBarrierException {
 try {
  return dowait(false, 0L);
 } catch (TimeoutException toe) {
  throw new Error(toe); // cannot happen
 }
 }
 /**
 * Main barrier code, covering the various policies.
 */
 private int dowait(boolean timed, long nanos)
 throws InterruptedException, BrokenBarrierException,
  TimeoutException {
 final ReentrantLock lock = this.lock;
 lock.lock();
  try {
  //獲取barrier當(dāng)前的 “代”也就是當(dāng)前循環(huán)
  final Generation g = generation;
  if (g.broken)
  throw new BrokenBarrierException();

  if (Thread.interrupted()) {
  breakBarrier();
  throw new InterruptedException();
  }
  // 每來一個線程調(diào)用await方法都會進(jìn)行減1
  int index = --count;
  if (index == 0) { // tripped
  boolean ranAction = false;
  try {
   final Runnable command = barrierCommand;
   // new CyclicBarrier 傳入 的barrierCommand, command.run()這個方法是同步的，如果耗時比較多的話,是否執(zhí)行的時候需要考慮下是否異步來執(zhí)行。
   if (command != null)
   command.run();
   ranAction = true;
   // 這個方法1. 喚醒所有阻塞的線程，2. 重置下count（count 每來一個線程都會進(jìn)行減1）和generation，以便于下次循環(huán)。
   nextGeneration();
   return 0;
  } finally {
   if (!ranAction)
   breakBarrier();
  }
  }

  // loop until tripped, broken, interrupted, or timed out
  for (;;) {
  try {
   // 進(jìn)入if條件，說明是不帶超時的await
   if (!timed)
    // 當(dāng)前線程會釋放掉lock，然后進(jìn)入到trip條件隊列的尾部，然后掛起自己，等待被喚醒。
   trip.await();
   else if (nanos > 0L)
    //說明當(dāng)前線程調(diào)用await方法時 是指定了 超時時間的！
   nanos = trip.awaitNanos(nanos);
  } catch (InterruptedException ie) {
   //Node節(jié)點在 條件隊列內(nèi) 時 收到中斷信號時 會拋出中斷異常！
   //g == generation 成立，說明當(dāng)前代并沒有變化。
   //! g.broken 當(dāng)前代如果沒有被打破，那么當(dāng)前線程就去打破，并且拋出異常..
   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.
   //執(zhí)行到else有幾種情況？
   //1.代發(fā)生了變化，這個時候就不需要拋出中斷異常了，因為 代已經(jīng)更新了，這里喚醒后就走正常邏輯了..只不過設(shè)置下 中斷標(biāo)記。
   //2.代沒有發(fā)生變化，但是代被打破了，此時也不用返回中斷異常，執(zhí)行到下面的時候會拋出 brokenBarrier異常。也記錄下中斷標(biāo)記位。
   Thread.currentThread().interrupt();
   }
  }
  //喚醒后，執(zhí)行到這里，有幾種情況？
  //1.正常情況，當(dāng)前barrier開啟了新的一代（trip.signalAll()）
  //2.當(dāng)前Generation被打破，此時也會喚醒所有在trip上掛起的線程
  //3.當(dāng)前線程trip中等待超時，然后主動轉(zhuǎn)移到 阻塞隊列 然后獲取到鎖 喚醒。
  if (g.broken)
   throw new BrokenBarrierException();
  //喚醒后，執(zhí)行到這里，有幾種情況？
  //1.正常情況，當(dāng)前barrier開啟了新的一代（trip.signalAll()）
  //2.當(dāng)前線程trip中等待超時，然后主動轉(zhuǎn)移到 阻塞隊列 然后獲取到鎖 喚醒。
  if (g != generation)
   return index;
  //喚醒后，執(zhí)行到這里，有幾種情況？
  //.當(dāng)前線程trip中等待超時，然后主動轉(zhuǎn)移到 阻塞隊列 然后獲取到鎖 喚醒。
  if (timed && nanos <= 0L) {
   breakBarrier();
   throw new TimeoutException();
  }
  }
 } finally {
  lock.unlock();
 }
 }