@Slf4j(topic = "c.CyclicBarrierPig")
public class CyclicBarrierPig {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(5);
        CyclicBarrier barrier = new CyclicBarrier(5, () -> {
            System.out.println("主人看看哪個豬跑最快，最肥...");
        });
        // 循環(huán)跑3次
        for (int i = 0; i < 3; i++) {
            // 5條豬開始跑
            for(int j = 0; j<5; j++) {
                int finalJ = j;
                service.submit(() -> {
                   log.info("pig{} is run .....", finalJ);
                    try {
                        // 隨機時間，模擬跑花費的時間
                        Thread.sleep(new Random().nextInt(5000));
                        log.info("pig{} reach barrier .....", finalJ);
                        barrier.await();
                    } catch (InterruptedException | BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                });
            }
        }
        service.shutdown();
    }
}

// barrier 實現(xiàn)是依賴于Condition條件隊列，condition 條件隊列必須依賴lock才能使用
private final ReentrantLock lock = new ReentrantLock();
// 線程掛起實現(xiàn)使用的 condition 隊列，當(dāng)前代所有線程到位，這個條件隊列內(nèi)的線程才會被喚醒
private final Condition trip = lock.newCondition();

// 代表多少個線程到達屏障開始觸發(fā)線程任務(wù)
private final int parties;	
// 表示當(dāng)前“代”還有多少個線程未到位，初始值為 parties
private int count;			

private final Runnable barrierCommand;

// 表示 barrier 對象當(dāng)前 代
private Generation generation = new Generation();
private static class Generation {
    // 表示當(dāng)前“代”是否被打破，如果被打破再來到這一代的線程 就會直接拋出 BrokenException 異常
    // 且在這一代掛起的線程都會被喚醒，然后拋出 BrokerException 異常。
    boolean broken = false;
}

public CyclicBarrie(int parties, Runnable barrierAction) {
    // 因為小于等于 0 的 barrier 沒有任何意義
    if (parties <= 0) throw new IllegalArgumentException();
    this.parties = parties;
    this.count = parties;
    // 可以為 null
    this.barrierCommand = barrierAction;
}

public int await() throws InterruptedException, BrokenBarrierException {
    try {
        return dowait(false, 0L);
    } catch (TimeoutException toe) {
        throw new Error(toe); // cannot happen
    }
}
// timed：表示當(dāng)前調(diào)用await方法的線程是否指定了超時時長，如果 true 表示線程是響應(yīng)超時的
// nanos：線程等待超時時長，單位是納秒
private int dowait(boolean timed, long nanos) {
    final ReentrantLock lock = this.lock;
    // 加鎖
    lock.lock();
    try {
        // 獲取當(dāng)前代
        final Generation g = generation;
        // 【如果當(dāng)前代是已經(jīng)被打破狀態(tài)，則當(dāng)前調(diào)用await方法的線程，直接拋出Broken異常】
        if (g.broken)
            throw new BrokenBarrierException();
		// 如果當(dāng)前線程被中斷了，則打破當(dāng)前代，然后當(dāng)前線程拋出中斷異常
        if (Thread.interrupted()) {
            // 設(shè)置當(dāng)前代的狀態(tài)為 broken 狀態(tài)，喚醒在 trip 條件隊列內(nèi)的線程
            breakBarrier();
            throw new InterruptedException();
        }
        // 邏輯到這說明，當(dāng)前線程中斷狀態(tài)是 false， 當(dāng)前代的 broken 為 false（未打破狀態(tài)）
        // 假設(shè) parties 給的是 5，那么index對應(yīng)的值為 4,3,2,1,0
        int index = --count;
        // 條件成立說明當(dāng)前線程是最后一個到達 barrier 的線程，【需要開啟新代，喚醒阻塞線程】
        if (index == 0) {
            // 柵欄任務(wù)啟動標(biāo)記
            boolean ranAction = false;
            try {
                final Runnable command = barrierCommand;
                if (command != null)
                    // 啟動觸發(fā)的任務(wù)
                    command.run();
                // run()未拋出異常的話，啟動標(biāo)記設(shè)置為 true
                ranAction = true;
                // 開啟新的一代，這里會【喚醒所有的阻塞隊列】
                nextGeneration();
                // 返回 0 因為當(dāng)前線程是此代最后一個到達的線程，index == 0
                return 0;
            } finally {
                // 如果 command.run() 執(zhí)行拋出異常的話，會進入到這里
                if (!ranAction)
                    breakBarrier();
            }
        }
        // 自旋，一直到條件滿足、當(dāng)前代被打破、線程被中斷，等待超時
        for (;;) {
            try {
                // 根據(jù)是否需要超時等待選擇阻塞方法
                if (!timed)
                    // 當(dāng)前線程釋放掉 lock，【進入到 trip 條件隊列的尾部掛起自己】，等待被喚醒
                    trip.await();
                else if (nanos > 0L)
                    nanos = trip.awaitNanos(nanos);
            } catch (InterruptedException ie) {
                // 被中斷后來到這里的邏輯
                // 當(dāng)前代沒有變化并且沒有被打破
                if (g == generation && !g.broken) {
                    // 打破屏障
                    breakBarrier();
                    // node 節(jié)點在【條件隊列】內(nèi)收到中斷信號時 會拋出中斷異常
                    throw ie;
                } else {
                    // 等待過程中代變化了，完成一次自我打斷
                    Thread.currentThread().interrupt();
                }
            }
			// 喚醒后的線程，【判斷當(dāng)前代已經(jīng)被打破，線程喚醒后依次拋出 BrokenBarrier 異?！?
            if (g.broken)
                throw new BrokenBarrierException();
            // 當(dāng)前線程掛起期間，最后一個線程到位了，然后觸發(fā)了開啟新的一代的邏輯
            if (g != generation)
                return index;
			// 當(dāng)前線程 trip 中等待超時，然后主動轉(zhuǎn)移到阻塞隊列
            if (timed && nanos <= 0L) {
                breakBarrier();
                // 拋出超時異常
                throw new TimeoutException();
            }
        }
    } finally {
        // 解鎖
        lock.unlock();
    }
}

private void breakBarrier() {
    // 將代中的 broken 設(shè)置為 true，表示這一代是被打破了，再來到這一代的線程，直接拋出異常
    generation.broken = true;
    // 重置 count 為 parties
    count = parties;
    // 將在trip條件隊列內(nèi)掛起的線程全部喚醒，喚醒后的線程會檢查當(dāng)前是否是打破的，然后拋出異常
    trip.signalAll();
}

private void nextGeneration() {
    // 將在 trip 條件隊列內(nèi)掛起的線程全部喚醒
    trip.signalAll();
    // 重置 count 為 parties
    count = parties;
    // 開啟新的一代，使用一個新的generation對象，表示新的一代，新的一代和上一代【沒有任何關(guān)系】
    generation = new Generation();
}