@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("主人看看哪個(gè)豬跑最快，最肥...");
        });
        // 循環(huán)跑3次
        for (int i = 0; i < 3; i++) {
            // 5條豬開(kāi)始跑
            for(int j = 0; j<5; j++) {
                int finalJ = j;
                service.submit(() -> {
                   log.info("pig{} is run .....", finalJ);
                    try {
                        // 隨機(jī)時(shí)間，模擬跑花費(fèi)的時(shí)間
                        Thread.sleep(new Random().nextInt(5000));
                        log.info("pig{} reach barrier .....", finalJ);
                        barrier.await();
                    } catch (InterruptedException | BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                });
            }
        }
        service.shutdown();
    }
}

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

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

private final Runnable barrierCommand;

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

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

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

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