public class Demo1 {
    public static void main(String[] args) {
        // 初始化一個(gè) CyclicBarrier，大小為 5，當(dāng) 5 個(gè)線程滿足條件之后，就執(zhí)行一次：執(zhí)行完畢！
        CyclicBarrier cyclicBarrier = new CyclicBarrier( 5, () -> {
            System.out.println("執(zhí)行完畢！");
        });
        // 為了測(cè)試是否能循環(huán)，這里循環(huán)設(shè)置為 20，預(yù)期的結(jié)果應(yīng)該是會(huì)執(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();  // 等待其他線程到齊，到齊了之后就會(huì)執(zhí)行一次
                } catch (BrokenBarrierException | InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

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

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

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

//切換柵欄到下一代
private void nextGeneration() {
  //喚醒條件隊(duì)列所有線程
  trip.signalAll();
  //設(shè)置計(jì)數(shù)器的值為需要攔截的線程數(shù)
  count = parties;
  //重新設(shè)置柵欄代次
  generation = new Generation();
}
//打破當(dāng)前柵欄
private void breakBarrier() {
  //將當(dāng)前柵欄狀態(tài)設(shè)置為打翻
  generation.broken = true;
  //設(shè)置計(jì)數(shù)器的值為需要攔截的線程數(shù)
  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 {
                // 模擬點(diǎn)先各自獨(dú)立運(yùn)行
                Thread.sleep( (int) (Math.random() * 1000) );
                // 集合點(diǎn) A
                cyclicBarrier.await();
                System.out.println(this.getName() + "，到達(dá)集合點(diǎn) A " + System.currentTimeMillis() );
                // 集合后模擬再各自獨(dú)立運(yùn)行
                Thread.sleep( (int) (Math.random() * 1000));
                // 集合點(diǎn) B
                cyclicBarrier.await();
                System.out.println(this.getName() + "，到達(dá)集合點(diǎn) B " + System.currentTimeMillis() );
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        // 定義出多個(gè) 線程
        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();
        }
    }
}