public class Demo1 {
    public static void main(String[] args) {
        // 初始化一個 CyclicBarrier，大小為 5，當 5 個線程滿足條件之后，就執(zhí)行一次：執(zhí)行完畢！
        CyclicBarrier cyclicBarrier = new CyclicBarrier( 5, () -> {
            System.out.println("執(zhí)行完畢！");
        });
        // 為了測試是否能循環(huán)，這里循環(huán)設置為 20，預期的結果應該是會執(zhí)行 4 次：執(zhí)行完畢！
        for (int i=0; i<20; i++) {
            int temp = i;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + ", 執(zhí)行到：" + temp );
                try{
                    cyclicBarrier.await();  // 等待其他線程到齊，到齊了之后就會執(zhí)行一次
                } catch (BrokenBarrierException | InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

//同步操作鎖
private final ReentrantLock lock = new ReentrantLock();
//線程攔截器
private final Condition trip = lock.newCondition();
//每次攔截的線程數
private final int parties;
//換代前執(zhí)行的任務
private final Runnable barrierCommand;
//表示柵欄的當前代
private Generation generation = new Generation();
//計數器
private int count;
//靜態(tài)內部類Generation
private static class Generation {
    Generation() {}                 // 防止訪問構造函數創(chuàng)建
    boolean broken;                 // 初始化為 false
}

//構造器，這里就是我們上面那個例子使用的構造器
public CyclicBarrier(int parties, Runnable barrierAction) {
  if (parties <= 0) throw new IllegalArgumentException();
  this.parties = parties;
  this.count = parties;
  this.barrierCommand = barrierAction;
}
// 構造器，只傳入一個 parties 的大小，不進行自定義任務
public CyclicBarrier(int parties) {
  this(parties, null);
}

// 非定時等待
public int await() throws InterruptedException, BrokenBarrierException {
  try {
    return dowait(false, 0L);
  } catch (TimeoutException toe) {
    throw new Error(toe);
  }
}
// 定時等待
public int await(long timeout, TimeUnit unit) throws InterruptedException, BrokenBarrierException, TimeoutException {
  return dowait(true, unit.toNanos(timeout));
}

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()) {
            // 如果中斷了，就會執(zhí)行下面三件事
            // 1. 將 generation 的 broken 標記設置為 true
            // 2. 重置 count 值
            // 3. 喚醒當前攔截的線程
            breakBarrier();
            throw new InterruptedException();
        }
        int index = --count;    // 每次都將計數器的值減 1
        if (index == 0) {  // // 計數器的值減為0，就會喚醒所有線程并轉換到下一代
            Runnable command = barrierCommand;
            if (command != null) {    // // 如果存在自定義的任務，這里就會做判斷，在喚醒所有線程之前執(zhí)行
                try {
                    command.run();
                } catch (Throwable ex) {
                    breakBarrier();
                    throw ex;
                }
            }
            nextGeneration();    // 喚醒所有線程，并轉到下一代
            return 0;
        }
        //官方注釋： loop until tripped, broken, interrupted, or timed out
        //這里循環(huán)是：如果計數器不為0則執(zhí)行此循環(huán)
        for (;;) {
            try {
                // 根據傳入的參數來決定是定時等待還是非定時等待
                if (!timed)
                    trip.await();
                else if (nanos > 0L)
                    nanos = trip.awaitNanos(nanos);
            } catch (InterruptedException ie) {
                if (g == generation && ! g.broken) {
                    // 如果當前線程在等待期間被中斷，則打破柵欄喚醒其他線程
                    breakBarrier();
                    throw ie;
                } else {
                     //若在捕獲中斷異常前已經完成在柵欄上的等待, 則直接調用中斷操作
                    Thread.currentThread().interrupt();
                }
            }
            if (g.broken)
                throw new BrokenBarrierException();
            if (g != generation) //如果線程因為換代操作而被喚醒則返回計數器的值
                return index;
            // 如果是因為時間到了而被喚醒則打破柵欄，拋出異常
            if (timed && nanos <= 0L) {
                breakBarrier();
                throw new TimeoutException();
            }
        }
    } finally {
        lock.unlock();    // 解鎖
    }
}

//切換柵欄到下一代
private void nextGeneration() {
  //喚醒條件隊列所有線程
  trip.signalAll();
  //設置計數器的值為需要攔截的線程數
  count = parties;
  //重新設置柵欄代次
  generation = new Generation();
}
//打破當前柵欄
private void breakBarrier() {
  //將當前柵欄狀態(tài)設置為打翻
  generation.broken = true;
  //設置計數器的值為需要攔截的線程數
  count = parties;
  //喚醒所有線程
  trip.signalAll();
}

public void reset() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        breakBarrier();   // break the current generation
        nextGeneration(); // start a new generation
    } finally {
        lock.unlock();
    }
}

public class Demo {
    static class Tourist extends Thread {
        CyclicBarrier cyclicBarrier;
        public Tourist(CyclicBarrier cyclicBarrier){
            this.cyclicBarrier = cyclicBarrier;
        }
        @Override
        public void run() {
            try {
                // 模擬點先各自獨立運行
                Thread.sleep( (int) (Math.random() * 1000) );
                // 集合點 A
                cyclicBarrier.await();
                System.out.println(this.getName() + "，到達集合點 A " + System.currentTimeMillis() );
                // 集合后模擬再各自獨立運行
                Thread.sleep( (int) (Math.random() * 1000));
                // 集合點 B
                cyclicBarrier.await();
                System.out.println(this.getName() + "，到達集合點 B " + System.currentTimeMillis() );
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        // 定義出多個 線程
        int num = 3;
        Tourist[] tourist = new Tourist[num];
        CyclicBarrier barrier = new CyclicBarrier(3, () -> {
            System.out.println("集合完畢： " + System.currentTimeMillis() + " 執(zhí)行的線程為： " + Thread.currentThread().getName());
        });
        for (int i = 0; i< num; i++){
            tourist[i] = new Tourist(barrier);
            tourist[i].start();
        }
    }
}