//參數(shù)parties：表示要到達(dá)屏障 (柵欄)的線程數(shù)量
//參數(shù)Runnable： 最后一個線程到達(dá)屏障之后要做的任務(wù)
?
//構(gòu)造方法1
public CyclicBarrier(int parties) 
//構(gòu)造方法2
public CyclicBarrier(int parties, Runnable barrierAction)
?
//線程調(diào)用await()方法表示當(dāng)前線程已經(jīng)到達(dá)柵欄，然后會被阻塞
public int await() throws InterruptedException, BrokenBarrierException {
    try {
        return dowait(false, 0L);
    } catch (TimeoutException toe) {
        throw new Error(toe); // cannot happen
    }
}
?
//帶時限的阻塞等待
public int await(long timeout, TimeUnit unit) throws InterruptedException,BrokenBarrierException,TimeoutException {
    return dowait(true, unit.toNanos(timeout));
}

//循環(huán)柵欄-可多次循環(huán)使用
   CyclicBarrier cyclicBarrier = new CyclicBarrier(5,()->{
        System.out.println(Thread.currentThread().getName()+" 完成最后任務(wù)！");
   });
?
   IntStream.range(1,6).forEach(i->{
        new Thread(()->{
            try {
                Thread.sleep(new Double(Math.random()*3000).longValue());
                System.out.println(Thread.currentThread().getName()+" 到達(dá)柵欄A");
                
                cyclicBarrier.await();//屏障點(diǎn)A，當(dāng)前線程會阻塞至此，等待計(jì)數(shù)器=0
                
                System.out.println(Thread.currentThread().getName()+" 沖破柵欄A");
            }catch (Exception e){
                e.printStackTrace();
            }
        }).start();
    });

 /** CyclicBarrier使用的排他鎖*/
    private final ReentrantLock lock = new ReentrantLock();
    /** barrier被沖破前，線程等待的condition*/
    private final Condition trip = lock.newCondition();
    /** barrier被沖破時，需要滿足的參與線程數(shù)。*/
    private final int parties;
    /* barrier被沖破后執(zhí)行的方法。*/
    private final Runnable barrierCommand;
    /** 當(dāng)其輪次 */
    private Generation generation = new Generation();
?
    /**
     *目前等待剩余的參與者數(shù)量。從 parties倒數(shù)到0。每個輪次該值會被重置回parties
     */
    private int count;

//構(gòu)造器1：指定本局要攔截的線程數(shù)parties 及 本局結(jié)束時要執(zhí)行的任務(wù)
public CyclicBarrier(int parties, Runnable barrierAction) {
    if (parties <= 0) throw new IllegalArgumentException();
    this.parties = parties;
    this.count = parties;
    this.barrierCommand = barrierAction;
}
?
//構(gòu)造器2
public CyclicBarrier(int parties) {
    this(parties, null);
}

private int dowait(boolean timed, long nanos) throws InterruptedException, BrokenBarrierException,TimeoutException {
    // 獲取獨(dú)占鎖
    final ReentrantLock lock = this.lock;
    lock.lock();//對共享資源count,generation操作前，需先上鎖保證線程安全
    try {
        // 當(dāng)前代--當(dāng)前輪次對象的引用
        final Generation g = generation;
        // 如果這輪次broken了，拋出異常
        if (g.broken)
            throw new BrokenBarrierException();
        // 如果線程中斷了，拋出異常
        if (Thread.interrupted()) {
            breakBarrier();//如果被打斷，通過此方法設(shè)置當(dāng)前輪次為broken狀態(tài)，通知當(dāng)前輪次所有等待的線程
            throw new InterruptedException();//拋出異常
        }
 
        //自旋前
        
        //1、count值-1
        int index = --count;
        // 2、判斷是否到0，若是，則沖破屏障點(diǎn)（說明最后一個線程已經(jīng)到達(dá)）
        if (index == 0) {
            boolean ranAction = false;
            try {
                final Runnable command = barrierCommand;
                // 3、執(zhí)行柵欄任務(wù)（若CyclicBarrier構(gòu)造時傳入了Runnable，則調(diào)用）
                if (command != null)
                    command.run();
                ranAction = true;
                // 4、更新一輪次，將count重置，將generation重置，喚醒之前等待的線程
                nextGeneration();
                return 0;
            } finally {
                // 如果執(zhí)行柵欄任務(wù)（command）的時候出現(xiàn)了異常，那么就認(rèn)為本輪次破環(huán)了
                if (!ranAction)
                    breakBarrier();
            }
        }
 
        //計(jì)數(shù)器沒有到0 =》開始自旋，直到屏障被沖破，或者interrupted或者超時
        for (;;) {
            try {
                 // 開始等待；如果沒有時間限制，則直接等待，直到被喚醒（讓其他線程進(jìn)入到lock的代碼塊執(zhí)行以上邏輯）
                if (!timed)
                    trip.await();//阻塞，此時會釋放鎖，以讓其他線程進(jìn)入await方法中，等待屏障被沖破后，向后執(zhí)行
                // 如果有時間限制，則等待指定時間
                else if (nanos > 0L)
                    nanos = trip.awaitNanos(nanos);
            } catch (InterruptedException ie) {
                // 如果當(dāng)前線程阻塞被interrupt了，并且本輪次還沒有被break，那么修改本輪次狀態(tài)為broken
                if (g == generation && ! g.broken) {
                    // 讓柵欄失效
                    breakBarrier();
                    throw ie;
                } else {
                    // 上面條件不滿足，說明這個線程不是這輪次的，就不會影響當(dāng)前這代柵欄的執(zhí)行，所以，就打個中斷標(biāo)記
                    Thread.currentThread().interrupt();
                }
            }
 
            // 當(dāng)有任何一個線程中斷了，就會調(diào)用breakBarrier方法,就會喚醒其他的線程，其他線程醒來后，也要拋出異常 
            if (g.broken)
                throw new BrokenBarrierException();
 
            // g != generation表示正常換輪次了，返回當(dāng)前線程所在柵欄的下標(biāo)
            // 如果 g == generation，說明還沒有換，那為什么會醒了？
            // 因?yàn)橐粋€線程可以使用多個柵欄，當(dāng)別的柵欄喚醒了這個線程，就會走到這里，所以需要判斷是否是當(dāng)前代。
            // 正是因?yàn)檫@個原因，才需要generation來保證正確。
            if (g != generation)
                return index;
            
            // 如果有時間限制，且時間小于等于0，銷毀柵欄并拋出異常
            if (timed && nanos <= 0L) {
                breakBarrier();
                throw new TimeoutException();
            }
        }//自旋
        
    } finally {
        // 釋放獨(dú)占鎖
        lock.unlock();
    }
}

private void nextGeneration() {
    trip.signalAll();//喚醒本輪次等待的線程
    count = parties;//重置count值為初始值，為下一輪次（代）使用
    generation = new Generation();//更新本輪次對象，這樣自旋中的線程才會跳出自旋。
}
?
private static class Generation {
    boolean broken = false;
}
?
private void breakBarrier() {
    generation.broken = true;//設(shè)置標(biāo)識
    count = parties;//重置count值為初始值
    trip.signalAll();//喚醒所有等待線程
}