public static void main(String[] args) {
        int N = 4;
        CyclicBarrier barrier  = new CyclicBarrier(N);
        for(int i=0;i<N;i++)
            new Writer(barrier).start();
    }
    static class Writer extends Thread{
        private CyclicBarrier cyclicBarrier;
        public Writer(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }
 
        @Override
        public void run() {
            System.out.println("線程"+Thread.currentThread().getName()+"正在寫入數(shù)據(jù)...");
            try {
                Thread.sleep(5000);      //以睡眠來模擬寫入數(shù)據(jù)操作
                System.out.println("線程"+Thread.currentThread().getName()+"寫入數(shù)據(jù)完畢，等待其他線程寫入完畢");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println("所有線程寫入完畢，繼續(xù)處理其他任務...");
        }
    }

public class CyclicBarrierTest {

    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier barrier  = new CyclicBarrier(N,new Runnable() {
            @Override
            public void run() {
                System.out.println("當前線程"+Thread.currentThread().getName());
            }
        });

        for(int i=0;i<N;i++)
            new Writer(barrier).start();
    }
    static class Writer extends Thread{
        private CyclicBarrier cyclicBarrier;
        public Writer(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            System.out.println("線程"+Thread.currentThread().getName()+"正在寫入數(shù)據(jù)...");
            try {
                Thread.sleep(3000);      //以睡眠來模擬寫入數(shù)據(jù)操作
                System.out.println("線程"+Thread.currentThread().getName()+"寫入數(shù)據(jù)完畢，等待其他線程寫入完畢");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println("所有線程寫入完畢，繼續(xù)處理其他任務...");
        }
    }

}

public class CyclicBarrierTest {


    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier barrier = new CyclicBarrier(N);

        for (int i = 0; i < N; i++) {
            if (i < N - 1)
                new Writer(barrier).start();
            else {
                try {
                    //運行時間遠小于2000(cyclicBarrier.await 指定時間) 就不會拋出TimeoutException
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                new Writer(barrier).start();
            }
            
        }
    }

    static class Writer extends Thread {
        private CyclicBarrier cyclicBarrier;

        public Writer(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            System.out.println("線程" + Thread.currentThread().getName() + "正在寫入數(shù)據(jù)...");
            try {
                Thread.sleep(3000);      //以睡眠來模擬寫入數(shù)據(jù)操作
                System.out.println("線程" + Thread.currentThread().getName() + "寫入數(shù)據(jù)完畢，等待其他線程寫入完畢");
                try {
                    cyclicBarrier.await(2000, TimeUnit.MILLISECONDS);
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "所有線程寫入完畢，繼續(xù)處理其他任務...");
        }
    }
}

public class CyclicBarrierTest {

    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier barrier  = new CyclicBarrier(N);

        for(int i=0;i<N;i++) {
            new Writer(barrier).start();
        }

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("CyclicBarrier重用");

        for(int i=0;i<N;i++) {
            new Writer(barrier).start();
        }
    }
    static class Writer extends Thread{
        private CyclicBarrier cyclicBarrier;
        public Writer(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            System.out.println("線程"+Thread.currentThread().getName()+"正在寫入數(shù)據(jù)...");
            try {
                Thread.sleep(3000);      //以睡眠來模擬寫入數(shù)據(jù)操作
                System.out.println("線程"+Thread.currentThread().getName()+"寫入數(shù)據(jù)完畢，等待其他線程寫入完畢");

                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"所有線程寫入完畢，繼續(xù)處理其他任務...");
        }
    }
}

    /** The lock for guarding barrier entry */
    private final ReentrantLock lock = new ReentrantLock();
    /** Condition to wait on until tripped */
    private final Condition trip = lock.newCondition();
    /** The number of parties */
    private final int parties;//攔截的線程數(shù)量
    /* The command to run when tripped */
    private final Runnable barrierCommand; //當屏障撤銷時，需要執(zhí)行的屏障操作
    //當前的Generation。每當屏障失效或者開閘之后都會自動替換掉。從而實現(xiàn)重置的功能。
    private Generation generation = new Generation();

    /**
     * Number of parties still waiting. Counts down from parties to 0
     * on each generation.  It is reset to parties on each new
     * generation or when broken.
     */
    private int count;

//帶Runnable參數(shù)的函數(shù)
 public CyclicBarrier(int parties, Runnable barrierAction) {
        if (parties <= 0) throw new IllegalArgumentException();
        this.parties = parties;//有幾個運動員要參賽
        this.count = parties;//目前還需要幾個運動員準備好
        //你要在所有線程都繼續(xù)執(zhí)行下去之前要執(zhí)行什么操作，可以為空
        this.barrierCommand = barrierAction;
    }
//不帶Runnable參數(shù)的函數(shù)
 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); // cannot happen
        }

   private int dowait(boolean timed, long nanos)
        throws InterruptedException, BrokenBarrierException,
               TimeoutException {
        final ReentrantLock lock = this.lock;
        lock.lock();//獲取ReentrantLock互斥鎖
        try {
            final Generation g = generation;//獲取generation對象

            if (g.broken)//如果generation損壞，拋出異常
                throw new BrokenBarrierException();

            if (Thread.interrupted()) {
                //如果當前線程被中斷，則調用breakBarrier方法，停止CyclicBarrier，并喚醒所有線程
                breakBarrier();
                throw new InterruptedException();
            }

            int index = --count;// 看到這里了吧，count減1 
            //index=0，也就是說，有0個線程未滿足CyclicBarrier條件，也就是條件滿足，
            //可以喚醒所有的線程了
            if (index == 0) {  // tripped
                boolean ranAction = false;
                try {
                   //這就是構造器的第二個參數(shù)，如果不為空的話，就執(zhí)行這個Runnable的run方法，
                   //你看，這里是執(zhí)行的是run方法，也就是說，并沒有新起一個另外的線程，
                   //而是最后一個執(zhí)行await操作的線程執(zhí)行的這個run方法。
                    final Runnable command = barrierCommand;
                    if (command != null)
                        command.run(); //同步執(zhí)行barrierCommand
                    ranAction = true;
                    nextGeneration(); //執(zhí)行成功設置下一個nextGeneration
                    return 0;
                } finally {
                    if (!ranAction) . //如果barrierCommand執(zhí)行失敗，進行屏障破壞處理
                        breakBarrier();
                }
            }
            //如果當前線程不是最后一個到達的線程
            // loop until tripped, broken, interrupted, or timed out
            for (;;) {
                try {
                    if (!timed)
                        trip.await(); //調用Condition的await()方法阻塞
                    else if (nanos > 0L)
                        nanos = trip.awaitNanos(nanos); //調用Condition的awaitNanos()方法阻塞
                } catch (InterruptedException ie) {
                //如果當前線程被中斷，則判斷是否有其他線程已經使屏障破壞。若沒有則進行屏障破壞處理，并拋出異常；否則再次中斷當前線程
                    if (g == generation && ! g.broken) {
                        breakBarrier();//執(zhí)行breakBarrier，喚醒所有線程
                        throw ie;
                    } else {
                        // We're about to finish waiting even if we had not
                        // been interrupted, so this interrupt is deemed to
                        // "belong" to subsequent execution.
                        Thread.currentThread().interrupt();
                    }
                }

                if (g.broken)//如果當前generation已經損壞，拋出異常
                    throw new BrokenBarrierException();

                if (g != generation)//如果generation已經更新?lián)Q代，則返回index
                    return index;
                //如果是參數(shù)是超時等待，并且已經超時，則執(zhí)行breakBarrier()方法
                //喚醒所有等待線程。
                if (timed && nanos <= 0L) {
                    breakBarrier();
                    throw new TimeoutException();
                }
            }
        } finally {
            lock.unlock();
        }
    }

private Generation generation = new Generation();

private static class Generation {
    boolean broken = false;
}

    private void nextGeneration() {
        // signal completion of last generation
        trip.signalAll();//調用Condition的signalAll方法，喚醒所有await的線程
        // set up next generation
        count = parties;//重置count值
        //生成新的Generation，表示上一代的所有線程已經喚醒，進行更新?lián)Q代
        generation = new Generation(); 
    }

    private void breakBarrier() {
        generation.broken = true;//表示當代因為線程被中斷，已經發(fā)成損壞了
        count = parties;//重置count值
        trip.signalAll();//調用Condition的signalAll方法，喚醒所有await的線程
    }

    public boolean isBroken() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return generation.broken;
        } finally {
            lock.unlock();
        }
    }

    //將屏障重置為其初始狀態(tài)。
    public void reset() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //喚醒所有等待的線程繼續(xù)執(zhí)行，并設置屏障中斷狀態(tài)為true
            breakBarrier();   // break the current generation
            //喚醒所有等待的線程繼續(xù)執(zhí)行，并設置屏障中斷狀態(tài)為false
            nextGeneration(); // start a new generation
        } finally {
            lock.unlock();
        }
    }

    //返回當前在屏障處等待的參與者數(shù)目，此方法主要用于調試和斷言。
    public int getNumberWaiting() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return parties - count;
        } finally {
            lock.unlock();
        }
    }