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

一：CyclicBarrier的工作原理

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

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

构造函数：

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

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更像是一个阀门，需要所有线程都到达，阀门才能打开，然后继续执行。