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

落日映苍穹つ 2022-06-02 01:56 315阅读 0赞

**1. 类说明**

--------------------

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

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_ifeve.com_concurrency-cyclicbarrier]  
[http://www.itzhai.com/the-introduction-and-use-of-cyclicbarrier.html\#read-more][http_www.itzhai.com_the-introduction-and-use-of-cyclicbarrier.html_read-more]  
[https://zhuanlan.zhihu.com/p/28637245][https_zhuanlan.zhihu.com_p_28637245]  
[https://www.jianshu.com/p/1716ce690637][https_www.jianshu.com_p_1716ce690637]

[70]: /images/20220602/c466271a02e64e3283de89eafcbdd58f.png
[http_ifeve.com_concurrency-cyclicbarrier]: http://ifeve.com/concurrency-cyclicbarrier/
[http_www.itzhai.com_the-introduction-and-use-of-cyclicbarrier.html_read-more]: http://www.itzhai.com/the-introduction-and-use-of-cyclicbarrier.html#read-more
[https_zhuanlan.zhihu.com_p_28637245]: https://zhuanlan.zhihu.com/p/28637245
[https_www.jianshu.com_p_1716ce690637]: https://www.jianshu.com/p/1716ce690637