CyclicBarrier(循环栅栏)的工作原理及实例

亦凉 2022-04-10 05:53 272阅读 0赞

一：CyclicBarrier的工作原理

CyclicBarrier 和 CountDownLatch 非常类似，它也可以实现线程间的技术等待，但是它的功能比 CountDownLatch 更加复杂和强大。主要应用场景和 CountDownLatch 类似。

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

构造函数：

![20181227215935233.png][]

cyclicBarrier.await(5000, TimeUnit.MILLISECONDS); //时间不能设置的太小，不然会报错

![20181227220011649.png][]

private int dowait(boolean timed, long nanos)核心方法如下：

/**
         * Main barrier code, covering the various policies.
         */
        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();
                }
    
                int index = --count;
                if (index == 0) {  // tripped
                    boolean ranAction = false;
                    try {
                        final Runnable command = barrierCommand;
                        if (command != null)
                            command.run();
                        ranAction = true;
                        nextGeneration();
                        return 0;
                    } finally {
                        if (!ranAction)
                            breakBarrier();
                    }
                }
    
                // loop until tripped, broken, interrupted, or timed out
                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 {
                            // 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)
                        throw new BrokenBarrierException();
    
                    if (g != generation)
                        return index;
    
                    if (timed && nanos <= 0L) {
                        breakBarrier();
                        throw new TimeoutException();
                    }
                }
            } finally {
                lock.unlock();
            }
        }

1：CyclicBarrier的使用场景

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

二：CyclicBarrier的使用实例

package com.github.springbootdemo.demo;
    
    import java.util.concurrent.CyclicBarrier;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    
    public class CyclicBarrierExample {
    
        //请求的数量
        private static final int threatCount = 550;
    
        //需要同步的线程数量
        private static final CyclicBarrier cyclicBarrier = new CyclicBarrier(5);
    
        public static void main(String[] args) throws Exception {
    
            //创建固定数量的线程池
            ExecutorService threadPool = Executors.newFixedThreadPool(10);
    
            for(int i=0;i<threatCount;i++){
                final int threadNum = i;
                Thread.sleep(1000);
                threadPool.execute(()->{
                    try {
                        test(threadNum);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                });
            }
            //关闭线程
            threadPool.shutdown();
        }
    
        public static void test(int threadNum) throws Exception{
            System.out.println("threadNum:" + threadNum + "is ready");
            try {
                cyclicBarrier.await(5000, TimeUnit.MILLISECONDS); //时间不能设置的太小，不然会报错
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println("threadNum:" + threadNum + "is finish");
        }
    
    }

运行结果如下：

threadNum:0is ready
    threadNum:1is ready
    threadNum:2is ready
    threadNum:3is ready
    threadNum:4is ready
    threadNum:4is finish
    threadNum:0is finish
    threadNum:1is finish
    threadNum:3is finish
    threadNum:2is finish
    threadNum:5is ready
    threadNum:6is ready

三：CyclicBarrier和CountDownLatch的区别

CountDownLatch是计数器，只能使用一次，而CyclicBarrier的计数器提供reset功能，可以多次使用。

CountDownLatch是计数器，线程完成一个记录一个，只不过计数不是递增而是递减，而CyclicBarrier更像是一个阀门，需要所有线程都到达，阀门才能打开，然后继续执行。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NDY5MDU1_size_16_color_FFFFFF_t_70][]

[20181227215935233.png]: /images/20220402/dbeb5f5bb6494a76babec76774eb71f9.png
[20181227220011649.png]: /images/20220402/f40133cc6d284485bc0901e74178fa7c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NDY5MDU1_size_16_color_FFFFFF_t_70]: /images/20220402/9c877ac4710d449aa2059d62c751eae2.png