栅栏不同于倒计时器的一点是倒计时器是一个或N个线程等待其他线程调用countdown()到指定次数后再继续执行，而栅栏是N个线程之间互相等待，当调用await()到达指定次数后就会唤醒所有等待线程，同时还可以在到达指定数量时触发一个定制的动作（Runnable，由最后一个调用await()方法并唤醒所有线程的那个线程执行)。另外栅栏是可以循环使用的。

栅栏的实现方式是独占锁+Condition条件来实现的。

先看个Demo：

package com.pzx.test005;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo {
    static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:SS ");
    static CyclicBarrier cyclicBarrier;

    public static void main(String[] args) {
        cyclicBarrier = new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                System.out.println(sdf.format(new Date()) + Thread.currentThread().getName() + " do something...");
            }
        });

        ThreadA threadA = new ThreadA();
        for(int i=0; i<5; i++) {
            Thread thread = new Thread(threadA, "t"+i);
            thread.start();
        }
    }

    static class ThreadA implements Runnable{
        @Override
        public void run() {
            System.out.println(sdf.format(new Date()) + Thread.currentThread().getName() + " begin work...");
            try {
                System.out.println(sdf.format(new Date()) + Thread.currentThread().getName() + " await...");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }

            System.out.println(sdf.format(new Date()) + Thread.currentThread().getName() + " continue work...");
        }
    }
}

执行结果：

2018-09-11 13:54:27 t0 begin work…
2018-09-11 13:54:27 t0 await…
2018-09-11 13:54:27 t4 begin work…
2018-09-11 13:54:27 t4 await…
2018-09-11 13:54:27 t1 begin work…
2018-09-11 13:54:27 t1 await…
2018-09-11 13:54:27 t3 begin work…
2018-09-11 13:54:27 t3 await…
2018-09-11 13:54:27 t2 begin work…
2018-09-11 13:54:27 t2 await…
2018-09-11 13:54:27 t2 do something…
2018-09-11 13:54:27 t2 continue work…
2018-09-11 13:54:27 t0 continue work…
2018-09-11 13:54:27 t4 continue work…
2018-09-11 13:54:27 t1 continue work…
2018-09-11 13:54:27 t3 continue work…

public class CyclicBarrier {
    // 内部类，因为栅栏可以循环使用，每使用一次都是一代，这个类可判断是否处于同一代
    private static class Generation {
        boolean broken = false;
    }
    // 可重入锁
    private final ReentrantLock lock = new ReentrantLock();
    // 创建Condition，释放所有线程的条件
    private final Condition trip = lock.newCondition();
    // 栅栏中的线程总个数
    private final int parties;
    // 当要释放时触发的动作
    private final Runnable barrierCommand;
    // 创建当前代
    private Generation generation = new Generation();
    // 还剩多少线程可以达到条件，进来一个线程就-1
    private int count;
    // 构造函数
    public CyclicBarrier(int parties, Runnable barrierAction) {
        if (parties <= 0) throw new IllegalArgumentException();
        this.parties = parties;
        this.count = parties;
        this.barrierCommand = barrierAction;
    }
    // 调用await方法阻塞，最后一个线程会唤醒所有线程
    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();
        try {
            // 获取当前代数
            final Generation g = generation;
            // 如果当前代的栅栏被破坏了就抛异常
            if (g.broken)
                throw new BrokenBarrierException();
            // 当前线程如果处于中断状态就清除中断标志，破坏栅栏，抛出被中断的异常
            if (Thread.interrupted()) {
                breakBarrier();
                throw new InterruptedException();
            }
            // 一个线程进来后，count-1
            int index = --count;
            // 如果count已经减到0了，说明是时候唤醒所有线程往下运行了
            if (index == 0) {  // tripped
                boolean ranAction = false;
                try {
                    final Runnable command = barrierCommand;
                    // 如果构造函数中有传入Runnable对象，就在唤醒所有线程之前执行Runnable里面
                    // 的run方法
                    if (command != null)
                        command.run();
                    ranAction = true;
                    // 重置参数，进入下一代
                    nextGeneration();
                    return 0;
                } finally {
                    // 如果上述唤醒的过程(command.run();)发生了什么意外导致异常了，就破坏当前 
                    // 的栅栏
                    if (!ranAction)
                        breakBarrier();
                }
            }

            // loop until tripped, broken, interrupted, or timed out
            // 循环，一直到要被唤醒了，或者栅栏被破坏了，或者线程被中断了，或者超时了
            for (;;) {
                try {
                    // 如果没有设置超时参数，就执行await（即当前线程阻塞，释放上面的独占锁，
                    // 等待被唤醒）
                    if (!timed)
                        trip.await();
                    // 如果设置了超时参数，就阻塞超时参数那么长的时间
                    else if (nanos > 0L)
                        nanos = trip.awaitNanos(nanos);
                } catch (InterruptedException ie) {
                    // 如果发生了中断异常

                    // 如果还是在当前代并且当前代没有被破坏
                    if (g == generation && ! g.broken) {
                        // 破坏栅栏，抛出异常
                        breakBarrier();
                        throw ie;
                    } else {
                        // 发生中断
                        Thread.currentThread().interrupt();
                    }
                }
                // 如果当前代被破坏了，就抛出异常
                if (g.broken)
                    throw new BrokenBarrierException();
                // 如果在这个执行过程中换代了就返回index(即当前count-1值)
                if (g != generation)
                    return index;
                // 输入的超时参数的合法性判断，不合法就破坏当前代的栅栏
                if (timed && nanos <= 0L) {
                    breakBarrier();
                    throw new TimeoutException();
                }
            }
        } finally {
            lock.unlock();
        }
    }
  
    // 开启下一代
    private void nextGeneration() {
        // 唤醒所有的等待的线程，相当于把栅栏拉开
        trip.signalAll();
        // 重置count和generation 
        count = parties;
        generation = new Generation();
    }
    // 破坏栅栏
    private void breakBarrier() {
        // 当前代被破坏置true，重置count，唤醒所有的线程
        generation.broken = true;
        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();
        }
    }