Java并发学习(十六)-并发工具CyclicBarrier

What is CyclicBarrier

从名字来看，barrier：栅栏，cyclic:循环的。
简单点说，它能够让一组数量线程在某一个时间点等待，当所有线程都到了，再让它们运行。
例如有这样一个情景，有n个excel表格数据，你需要获取他们所有的数据后，再进行下一步运算。利用CyclicBarrier来做，首先需要开n个线程，等这n个线程都完成到达这个点，再进行下一步运算。
首先看它的内部构造：

CyclicBarrier结构

记得开始讲ReentrantLock的时候，说道Condition这个类，它和普通的wait和notify有区别，因为它能够唤醒一组线程，这里可以参看： Java并发学习(十二)-ReentrantLock分析 。
所以这里思路就简单了，没错，利用ReentranLock和Condition来实现。

public class CyclicBarrier {    /**     * 每一个barrier，都代表这一个Generation实例。当barrier损坏或者重置是，generation会改变。     */    private static class Generation {        boolean broken = false;    }    // 利用可重入锁，reentrantlock，守护栅栏的进入    private final ReentrantLock lock = new ReentrantLock();    //等待，知道被损坏。    private final Condition trip = lock.newCondition();    //代表进入数量    private final int parties;    //当所有线程到达时候，需要做的事。    private final Runnable barrierCommand;    ..}

简单列举出几点：

• 从cyclic知道，一个Cyclic是可以循环使用的，就好比去银行换整钞，到100你就能换一张1百的，可以循环利用。这个是通过Generation 这个静态内部类来实现的。
• ReentrantLock和Condition来控制挂起以及唤醒操作。
• 可以自定义barrierCommand ，即当所有线程都到达时，先执行barrierCommand 线程，在唤醒所有等待线程。具体分到时间片则有区别。

构造方法

• CyclicBarrier(int parties)：当给定数量的参与者（线程）等待它时，它将跳闸，自动唤醒所有线程并运行。
• CyclicBarrier(int parties, Runnable barrierAction)：当给定数量的参与者（线程）等待它时将会跳闸，并首先执行barrierAction线程。然后唤醒其他线程，这些由最后进来的线程执行。

接下来分析等待代码。

await方法

当需要利用CyclicBarrier进行等待时候，调用await方法：

    public int await() throws InterruptedException, BrokenBarrierException {        try {            //强行等待。不带超时            return dowait(false, 0L);        } catch (TimeoutException toe) {            throw new Error(toe); // cannot happen        }    }

再看dowait方法：

    private int dowait(boolean timed, long nanos)        throws InterruptedException, BrokenBarrierException,               TimeoutException {        final ReentrantLock lock = this.lock;        //加锁        lock.lock();        try {            //获取generation            final Generation g = generation;            //如果g，被破坏了，也就是为true了，那么就报错。            if (g.broken)                throw new BrokenBarrierException();            //如果线程中断了。当前线程，那么也报错。            if (Thread.interrupted()) {                breakBarrier();                throw new InterruptedException();            }            //先自减。然后看是否需要运行command            //也就是不用把最后一个也await了，直接让他运行。            int index = --count;            if (index == 0) {  // tripped  绊倒。                //都到了，开始运行。                boolean ranAction = false;                try {                    final Runnable command = barrierCommand;                    if (command != null)                        command.run();                    ranAction = true;                    //更新generation，并唤醒所有线程。                    nextGeneration();                    return 0;                } finally {                    if (!ranAction)                        //打破栅栏，让所有线程都运行。                        breakBarrier();                }            }            // loop until tripped, broken, interrupted, or timed out            //自旋，直到到齐运行，generation被破坏，中断，或者超时。            for (;;) {                try {                    //等待，有超时的等待，以及普通无限等待等。                    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();                if (g != generation)                    return index;                if (timed && nanos <= 0L) {                    breakBarrier();                    throw new TimeoutException();                }            }        } finally {            //释放锁。            lock.unlock();        }    }

代码虽长，但是理解还是比较简单的，重要注释写在代码里面了，这里讲讲具体思路：
1. 首先等待操作加锁操作。
2. 判断generation是否改变，是否中断等。
3. 将count自减操作，如果已经满足开启栅栏要求，则不对最后一个线程进行await操作，直接signalAll其他线程。
4. 检查完后，则进行自旋操作，直到到齐运行，generation被破坏，中断，或者超时。
5. 最后释放锁。

例子

public class CyclicBarrierTest {    private static CyclicBarrier cyclicBarrier;    static class CyclicBarrierThread extends Thread {        public void run() {            System.out.println(Thread.currentThread().getName() + "我走完了run了");            // 等待            try {                cyclicBarrier.await();            } catch (Exception e) {                e.printStackTrace();            }        }    }    public static void main(String[] args) {        cyclicBarrier = new CyclicBarrier(3, new Runnable() {            public void run() {                System.out.println("大家都走完了");            }        });        for (int i = 0; i < 3; i++) {            new CyclicBarrierThread().start();        }    }}

输出结果如下：

参考资料：
1. https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CyclicBarrier.html