并发编程(9)：CyclicBarrier的基本使用与实现原理

1、什么是CyclicBarrier？

        CyclicBarrier的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一
    组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会
    开门，所有被屏障拦截的线程才会继续运行。

 

2、CyclicBarrier的使用场景？

      1、我么可以使用CyclicBarrier来模拟并发。其他的场景自己脑补。

 

3、CyclicBarrier的构造函数：

      构造器1：CyclicBarrier默认的构造方法是CyclicBarrier（int parties），其参数表示屏障拦截的线程数 量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。

        使用案例：

public class CyclicBarrierDemo {

    public static CyclicBarrier cyclicBarrier = new CyclicBarrier(5);

    public static void main(String[] args) throws InterruptedException, BrokenBarrierException {
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    Thread.sleep(2000);
                    cyclicBarrier.await(); //使用珊栏将线程阻塞在此

                    //当珊栏达到数量后，所有的线程同时执行sayHello()方法，因此我们可以使用CyclicBarrier来并发执行一个方法。
                    sayHello();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },"T" + i).start();
        }

        Thread.sleep(5000);
        System.out.println("结束。。。");
    }

    public static void sayHello() throws BrokenBarrierException, InterruptedException {
        System.out.println(Thread.currentThread().getName() + ": hello . . .");
    }
}

     构造器2：CyclicBarrier（int parties，Runnable barrierAction），用于在线程到达屏障时，优先执行barrierAction，方便处理更复杂的业务场景。注意！！！barrierAction只会有一条线程去执行，也就是只会执行一次，一般是最后一个到达屏障的线程去执行barrierAction 任务。

      使用案例1：

public class CyclicBarrierDemo2 {

    static CyclicBarrier cyclicBarrier = new CyclicBarrier(2, new Task());

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println("执行完 Task 后，T1 继续执行");
        },"T1").start();

        Thread.sleep(1000);

        new Thread(() -> {
            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println("执行完 Task 后，T2 继续执行");
        },"T2").start();

    }

    static class Task implements Runnable {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + ":run task...");
        }
    }
}

       使用案例2：

public class CyclicBarrierDemo3 implements Runnable {

    /**
     * 创建一个数量为4的个屏障，处理完之后执行当前类的run方法
     */
    private CyclicBarrier c = new CyclicBarrier(4, this);
    /**
     * 假设只有4个sheet，所以只启动4个线程
     */
    private Executor executor = Executors.newFixedThreadPool(4);
    /**
     * 保存每个sheet计算出的银流结果
     */
    private ConcurrentHashMap<String, Integer> sheetBankWaterCount = new ConcurrentHashMap<>();

    private void count() {
        for (int i = 0; i < 4; i++) {
            executor.execute(() -> {
                // 计算当前sheet的银流数据，计算代码省略
                sheetBankWaterCount.put(Thread.currentThread().getName(), 1);
                // 银流计算完成，插入一个屏障
                try {
                    c.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            });
        }
    }

    @Override
    public void run() {
        int result = 0;
        // 汇总每个sheet计算出的结果
        for (Map.Entry<String, Integer> sheet : sheetBankWaterCount.entrySet()) {
            result += sheet.getValue();
        }               
        // 将结果输出
        sheetBankWaterCount.put("result", result);
        System.out.println(result);
    }

    public static void main(String[] args) {
        CyclicBarrierDemo3 bankWaterCount = new CyclicBarrierDemo3();
        bankWaterCount.count();
    }
}

 

4、CyclicBarrier的实现原理：

      从CyclicBarrier的api来说，跟CountLDownLatch的api差不多，那么实现方式呢？我们知道CountLDownLatch的实现是使用了AQS同步队列来实现的。那么CyclicBarrier呢？我们先看看CyclicBarrier的成员比变量：

public class CyclicBarrier {
    //定义了一把可重入锁，因为有全局变量parties、count需要并发操作
    private final ReentrantLock lock = new ReentrantLock();

    //使用重入锁构建一个Condition（等待队列）
    private final Condition trip = lock.newCondition();

    //屏障的线程数量，不会进行-1，是使用count进行-1，为什么不使用parties 进行-1呢？是因为CyclicBarrier 允许重置。
    private final int parties;
   
    //达到屏障线程数量后首先执行的Runable 任务。
    private final Runnable barrierCommand;

    
    private Generation generation = new Generation();

    //线程数量，当有线程到达屏障就-1。
    private int count;



    private static class Generation {
        boolean broken = false;
    }

           从成员变量中我们可以看出CyclicBarrier 的实现方式是使用ReentrantLock来保证屏障线程数量的写操作，而阻塞线程则是使用Condition等待队列。

           1、我们先来看看构造函数：

    public CyclicBarrier(int parties, Runnable barrierAction) {
        if (parties <= 0) throw new IllegalArgumentException();

        //设置屏障的线程数量
        this.parties = parties;

        //将count变量赋值为屏障的线程数量
        this.count = parties;

        //设置屏障的到达执行任务，不传就是null
        this.barrierCommand = barrierAction;
    }

          2、接下来我们来看看await()：

    public int await() throws InterruptedException, BrokenBarrierException {
        try {
            return dowait(false, 0L);
        } catch (TimeoutException toe) {
            throw new Error(toe); // cannot happen
        }
    }




    private int dowait(boolean timed, long nanos)
        throws InterruptedException, BrokenBarrierException,
               TimeoutException {
        final ReentrantLock lock = this.lock;

        //加锁
        lock.lock();
        try {
            final Generation g = generation;

            //默认g的broken 是false
            if (g.broken)
                throw new BrokenBarrierException();

              如果线程是被中断的，那就破坏CyclicBarrier，破坏就是将g的broken设置为true，唤醒被
              阻塞的线程，且重新将count=parties，然后再抛出InterruptedException异常
            if (Thread.interrupted()) {
                breakBarrier();
                throw new InterruptedException();
            }

            //再加锁的环境下降count 进行 -1
            int index = --count;
            if (index == 0) {  // tripped
                //如果count 进行-1后 为0 了，说明最后一个线程达到屏障了，那就看是唤醒所有阻塞的线程
                boolean ranAction = false;
                try {
                    //获取barrierCommand 的Runable任务，使用最后一个到达屏障的线程执行。
                    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
            //如果count 进行 -1后不为0，说明屏障还没达到完全，那就阻塞当前线程。
            for (;;) {
                try {
                    if (!timed)

                        //使用Condition等待队列来阻塞当前线程。
                        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();
        }
    }



    //开始下一代，就是唤醒所有被阻塞的线程，且将count再次赋值为parties，generation重新创建一个赋值
    private void nextGeneration() {
        // signal completion of last generation
        //唤醒在Condition 等待队列中的所有线程。
        trip.signalAll();

        // set up next generation
        //重置count=parties
        count = parties;

        //重置generation = new Generation();
        generation = new Generation();
    }

            上面就是CyclicBarrier的实现，使用ReentrantLock来并发修改屏障的线程数量，使用Condition.await()方法来阻塞线程，当屏障达到后，使用Condition.signalAll()来唤醒所有被阻塞的线程。