Java多线程-并发工具类（一）同步屏障CyclicBarrier

1. 类说明

---

CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。CyclicBarrier默认的构造方法是CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。

CyclicBarrier的计数器可以使用reset() 方法重置。所以CyclicBarrier能处理更为复杂的业务场景，比如如果计算发生错误，可以重置计数器，并让线程们重新执行一次。
CyclicBarrier还提供其他有用的方法，比如getNumberWaiting方法可以获得CyclicBarrier阻塞的线程数量。isBroken方法用来知道阻塞的线程是否被中断。

2. 使用场景

---

CyclicBarrier可以用于多线程计算数据，最后合并计算结果的应用场景。比如我们用一个Excel保存了用户所有银行流水，每个Sheet保存一个帐户近一年的每笔银行流水，现在需要统计用户的日均银行流水，先用多线程处理每个sheet里的银行流水，都执行完之后，得到每个sheet的日均银行流水，最后，再用barrierAction用这些线程的计算结果，计算出整个Excel的日均银行流水。

3. 常用方法

---

构造方法摘要

CyclicBarrier(int parties)
　　创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，但它不会在每个 barrier 上执行预定义的操作。
CyclicBarrier(int parties, Runnable barrierAction)
　　创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，并在启动 barrier 时执行给定的屏障操作，该操作由最后一个进入 barrier 的线程执行。用于在线程到达屏障时，优先执行barrierAction，方便处理更复杂的业务场景。

方法摘要

`int await() `
　　在所有参与者都已经在此 barrier 上调用 await 方法之前，将一直等待。 
　　返回：到达的当前线程的索引。索引0标识最后一个到达的线程，索引 getParties() - 1 指示将到达的第一个线程
`int await(long timeout, TimeUnit unit) `
　　在所有参与者都已经在此屏障上调用 await 方法之前，将一直等待。 
`int getNumberWaiting() `
　　返回当前在屏障处等待的参与者数目。 
`int getParties() `
　　返回要求启动此 barrier 的参与者数目。 
`boolean isBroken() `
　　查询此屏障是否处于损坏状态。 
`void reset() `
　　 将屏障重置为其初始状态。 

4. 使用示例

---

如下的示例，演示了如何使用 CyclicBarrier 实现线程同步。CyclicBarrierTest 测试类定义了线程数 threadNums 和 CyclicBarrier 实例 barrier，在构造函数中创建了 CyclicBarrier 实例，当所有线程都到达栅栏处时打印到达提示， 在 test 方法中创建线程，线程启动后调用 await 方法等待，并打印当前线程是第几个到达栅栏。

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

     public class CyclicBarrierTest {
        private int threadNums;
        private CyclicBarrier barrier;

        public CyclicBarrierTest(int threadNums) {
            this.threadNums = threadNums;
            barrier = new CyclicBarrier(threadNums, () -> println("All " + threadNums + " threads reached barrier.开始后续任务。"));
        }

        private void println(String msg) {
            SimpleDateFormat sdf = new SimpleDateFormat("[YYYY-MM-dd HH:mm:ss:SSS] ");
            System.out.println(sdf.format(new Date()) + msg);
        }

        public void test() {
            for (int i = 0; i < threadNums; i++) {
                new Thread(() -> {
                    println(Thread.currentThread().getName() + " start!");
                    try {
                        int await = barrier.await();
                        int parties = barrier.getParties();
                        int index = parties - await;
                        // 这组线程全部到达屏障后，再全部同时执行后续任务
                        println(Thread.currentThread().getName() + " arrive index-" + index + " await-" + await);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }).start();
            }
        }
        public static void main(String[] args) throws Exception {
            new CyclicBarrierTest(6).test();
            //new CyclicBarrierTest(6).test2();
        }   
    }   

以启动 6 个线程为例，执行结果如下。6 个线程几乎同时启动，1 毫秒后同时到达栅栏并打印出 “All 6 threads reached barrier”，6 个线程到达的次序是Thread-1 Thread-0 Thread-5 Thread-2 Thread-4 Thread-3。index-后面的数字（从小到大）指出了到达的顺序，正好和await相反。

await返回值说明：索引 getParties() - 1 指示将到达的第一个线程，零指示最后一个到达的线程。数值越大越先到。

[2018-04-04 15:40:30:224] Thread-1 start!
[2018-04-04 15:40:30:224] Thread-0 start!
[2018-04-04 15:40:30:224] Thread-5 start!
[2018-04-04 15:40:30:224] Thread-2 start!
[2018-04-04 15:40:30:224] Thread-4 start!
[2018-04-04 15:40:30:224] Thread-3 start!
[2018-04-04 15:40:30:225] All 6 threads reached barrier.开始后续任务。
[2018-04-04 15:40:30:236] Thread-1 arrive index-1 await-5 parties-6
[2018-04-04 15:40:30:236] Thread-3 arrive index-6 await-0 parties-6
[2018-04-04 15:40:30:236] Thread-2 arrive index-4 await-2 parties-6
[2018-04-04 15:40:30:236] Thread-5 arrive index-3 await-3 parties-6
[2018-04-04 15:40:30:236] Thread-0 arrive index-2 await-4 parties-6
[2018-04-04 15:40:30:236] Thread-4 arrive index-5 await-1 parties-6

5. 使用示例二

---

如下的示例增加了 test2 方法，来测试 CyclicBarrier 的其他方法。各个线程的创建时间差了 300 ms，创建线程时打印出此时栅栏处正在等待的线程个数，await 等待的时间为 1s 。当 CyclicBarrier 等待超时时，超时的线程打印超时提示和总的线程数，被 broken 的线程打印 broken 提示。

    public void test2() throws Exception {
        for (int i = 0; i < threadNums; i++) {
            new Thread(() -> {
                println(Thread.currentThread().getName() + " start with " + barrier.getNumberWaiting()
                        + " threads waiting");
                try {
                    barrier.await(1, TimeUnit.SECONDS);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    println(Thread.currentThread().getName() + " broken " + barrier.isBroken());
                } catch (TimeoutException e) {
                    println(Thread.currentThread().getName() + " time out to wait " + barrier.getParties() + " threds");
                }
            }).start();
            Thread.sleep(300);
        }
    }

从理论上分析，按照 300 ms 间隔创建线程，超时时间为 1s ，则在第 4 个线程创建并等待时发生超时并 broken 其他线程，创建第 5 个线程时已经没有线程等待。

以 6 个线程为例，执行结果如下。Thread-0、Thread-1、Thread-2 依次启动并等待，此时并没有超时一切正常。Thread-3 启动后，时间已经达到 1s，此时 Thread-0 等待超时打印超时提示，Thread-1、Thread-2、Thread-3 同时收到 break 消息进入 broken 状态并打印 broken 提示。在此之后，Thread-4、Thread-5 创建并启动，已经没有线程在栅栏处等待，直接进入 broken 状态并打印 broken 提示。

[2017-12-29 16:45:19:784] Thread-0 start with 0 threads waiting
[2017-12-29 16:45:20:053] Thread-1 start with 1 threads waiting
[2017-12-29 16:45:20:353] Thread-2 start with 2 threads waiting
[2017-12-29 16:45:20:653] Thread-3 start with 3 threads waiting
[2017-12-29 16:45:20:786] Thread-1 broken true
[2017-12-29 16:45:20:786] Thread-2 broken true
[2017-12-29 16:45:20:786] Thread-3 broken true
[2017-12-29 16:45:20:786] Thread-0 time out to wait 6 threds
[2017-12-29 16:45:20:953] Thread-4 start with 0 threads waiting
[2017-12-29 16:45:20:953] Thread-4 broken true
[2017-12-29 16:45:21:253] Thread-5 start with 0 threads waiting
[2017-12-29 16:45:21:253] Thread-5 broken true

总结

1. CyclicBarrier 允许一系列线程相互等待对方到达一个点，正如 barrier表示的意思，该点就像一个栅栏，先到达的线程被阻塞在栅栏前，必须等到所有线程都到达了才能够通过栅栏；
2. CyclicBarrier持有一个变量 parties，表示需要全部到达的线程数量；先到达的线程调用 barrier.await方法进行等待，一旦到达的线程数达到 parties 变量所指定的数，栅栏打开，所有线程都可以通过；
3. CyclicBarrier构造方法接受另一个 Runnable 类型参数 barrierAction，该参数表明再栅栏被打开的时候需要采取的动作，null表示不采取任何动作，注意该动作将会在栅栏被打开而所有线程接着运行前被执行；
4. CyclicBarrier是可重用的，当最后一个线程到达的时候，栅栏被打开，所有线程通过之后栅栏重新关闭，进入下一代；
5. CyclicBarrier.reset方法能够手动重置栅栏，此时正在等待的线程会收到 BrokenBarrierException异常。

---

参考：
http://ifeve.com/concurrency-cyclicbarrier/
http://www.itzhai.com/the-introduction-and-use-of-cyclicbarrier.html#read-more
https://zhuanlan.zhihu.com/p/28637245
https://www.jianshu.com/p/1716ce690637