突击并发编程JUC系列-并发工具 CyclicBarrier

突击并发编程JUC系列演示代码地址：
https://github.com/mtcarpenter/JavaTutorial

俗话说趁热要打铁,上篇中介绍的 CountDownLatch 的基本用法， CountDownLatch 计数器是一次性的，也就是等到计数器值变为0后，再调用CountDownLatch的await和countdown方法都会立刻返回，这就起不到线程同步的效果了。

对于部分业务需要多次循环使用，就可以使用本章节的 CyclicBarrier，CyclicBarrier的字面意思是可循环使用（Cyclic）的屏障（Barrier），它同样拥有 CountDownLatch的功能，CyclicBarrier的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。

重要方法

构造参数
- CyclicBarrier(int parties): parties 表示的是参与的线程个数，这个数字通过构造方法进行传递。
- CyclicBarrier(int parties, Runnable barrierAction): 可以接受一个Runnable参数 ,此参数表示栅栏动作，当所有线程到达栅栏后，在所有线程执行下一步动作前，运行参数中的动作，这个动作由最后一个到达栅栏的线程执行。
await()
- await(): 当前线程调用CyclicBarrier的该方法时会被阻塞，直到满足下面条件之一才会返回： parties个线程都调用了await（）方法，也就是线程都到了屏障点；其他线程调用了当前线程的interrupt（）方法中断了当前线程，则当前线程会抛出InterruptedException异常而返回；与当前屏障点关联的Generation对象的broken标志被设置为true时，会抛出BrokenBarrierException异常，然后返回。
- await(long timeout, TimeUnit unit): 当前线程调用CyclicBarrier的该方法时会被阻塞，直到满足下面条件之一才会返回：parties个线程都调用了await（）方法，也就是线程都到了屏障点，这时候返回true；设置的超时时间到了后返回false；其他线程调用当前线程的interrupt（）方法中断了当前线程，则当前线程会抛出InterruptedException异常然后返回；与当前屏障点关联的Generation对象的broken标志被设置为true时，会抛出BrokenBarrierException异常，然后返回。

案例上手

分组等待

跟前面countDownLatch一样通过学生的案例进行讲解，新日小学的同学全部已在操场上，但是操场的出口的只有三个，出口同时只能容纳三个年级，先整理好的三个年级为一组先出，后面的年级为另一组进行出场，示例如下：

public class CyclicBarrierExample1 {

    private final static int gradeNum = 6;

    private static CyclicBarrier barrier = new CyclicBarrier(3);

    public static void main(String[] args) throws Exception {
        ExecutorService exec = Executors.newScheduledThreadPool(gradeNum);
        System.out.println("通知、通知，请准备的年级先出发.....");
        for (int i = 0; i < gradeNum; i++) {
            TimeUnit.SECONDS.sleep(1);
            int gradeName = i + 1;
            exec.submit(() -> {
                try {
                    wait(gradeName);
                } catch (Exception e) {
                }
            });
        }
        exec.shutdown();
    }

    private static void wait(int gradeName) throws Exception {
        TimeUnit.SECONDS.sleep(1);
        System.out.println(gradeName + "年级所有同学来到了出口......");
        barrier.await();
        System.out.println(gradeName + "年级所有同学到出发");
    }
}

每个子任务在执行完自己的逻辑后会调用await方法。一开始计数器值为 3 ,相当于三个班级，当第一个线程调用await方法时，计数器值会递减为 1。由于此时计数器值不为 0，所以当前线程就到了屏障点而被阻塞。然后第二个线程调用await 时，会进入屏障，计数器值也会递减，现在计数器值为 0，执行完毕后退出屏障点，继续向下运行。

运行结果如下：

通知、通知，请准备的年级先出发.....
1年级所有同学来到了出口......
2年级所有同学来到了出口......
3年级所有同学来到了出口......
3年级所有同学到出发
1年级所有同学到出发
2年级所有同学到出发
4年级所有同学来到了出口......
5年级所有同学来到了出口......
6年级所有同学来到了出口......
6年级所有同学到出发
5年级所有同学到出发
4年级所有同学到出发

超时等待

为了早日达到植树场地，学校领导规定每一个年级从操场出去的时间为 2 秒，对于超时的引起的异常，再进行异常处理，示例如下

public class CyclicBarrierExample2 {

    private final static int gradeNum = 6;

    private static CyclicBarrier barrier = new CyclicBarrier(3);

    public static void main(String[] args) throws Exception {
        ExecutorService exec = Executors.newScheduledThreadPool(gradeNum);
        System.out.println("通知、通知，请准备的年级先出发.....");
        for (int i = 0; i < gradeNum; i++) {
            TimeUnit.SECONDS.sleep(1);
            int gradeName = i + 1;
            exec.submit(() -> {
                try {
                    wait(gradeName);
                } catch (Exception e) {
                }
            });
        }
        exec.shutdown();
    }

    private static void wait(int gradeName) throws Exception {
        TimeUnit.SECONDS.sleep(1);
        System.out.println(gradeName + "年级所有同学来到了出口......");
        try {
            barrier.await(2000, TimeUnit.MILLISECONDS);
        } catch (Exception e) {
            System.out.println("CyclicBarrier 超时异常:  " + gradeName + "年级-" + e);
        }
        System.out.println(gradeName + "年级所有同学到出发");
    }
}

与上面的例子相比，CyclicBarrier 可以设置超时时间，如barrier.await(2000, TimeUnit.MILLISECONDS); 子线程超过两秒，就抛出异常，根据自己的业务是中断还是继续向下运行。
运行结果如下：

通知、通知，请准备的年级先出发.....
1年级所有同学来到了出口......
2年级所有同学来到了出口......
3年级所有同学来到了出口......
3年级所有同学到出发
1年级所有同学到出发
2年级所有同学到出发
4年级所有同学来到了出口......
5年级所有同学来到了出口......
6年级所有同学来到了出口......
CyclicBarrier 超时异常:  4年级-java.util.concurrent.TimeoutException
4年级所有同学到出发
CyclicBarrier 超时异常:  5年级-java.util.concurrent.BrokenBarrierException
5年级所有同学到出发
CyclicBarrier 超时异常:  6年级-java.util.concurrent.BrokenBarrierException
6年级所有同学到出发

回调

每一个年级达到入口之后，汇报给领导，领导进行接下来的安排。示例如下：

public class CyclicBarrierExample3 {

    private final static int gradeNum = 6;

    private static CyclicBarrier barrier = new CyclicBarrier(3, new Runnable() {
        @Override
        public void run() {
            System.out.println("******所有子线程达到屏障******");
        }
    });

    public static void main(String[] args) throws Exception {
        ExecutorService exec = Executors.newScheduledThreadPool(gradeNum);
        System.out.println("通知、通知，请准备的年级先出发.....");
        for (int i = 0; i < gradeNum; i++) {
            TimeUnit.SECONDS.sleep(1);
            int gradeName = i + 1;
            exec.submit(() -> {
                try {
                    wait(gradeName);
                } catch (Exception e) {
                }
            });
        }
        exec.shutdown();
    }

    private static void wait(int gradeName) throws Exception {
        TimeUnit.SECONDS.sleep(1);
        System.out.println(gradeName + "年级所有同学来到了出口......");
        barrier.await();
        System.out.println(gradeName + "年级所有同学到出发");
    }
}

如上代码创建了一个 CyclicBarrier 对象，其第一个参数为计数器初始值，第二个参数Runable是当计数器值为 0 是需要执行的任务。当计数器值为 0，这时就会去执行CyclicBarrier 构造函数中的任务，执行完毕后退出屏障点，继续向下运行。

`CyclicBarrier`与`CountDownLatch` 区别

CyclicBarrier与CountDownLatch可能容易混淆，我们强调下它们的区别。

CountDownLatch的参与线程是有不同角色的，有的负责倒计时，有的在等待倒计时变为 0，负责倒计时和等待倒计时的线程都可以有多个，用于不同角色线程间的同步。
CyclicBarrier的参与线程角色是一样的，用于同一角色线程间的协调一致。
CountDownLatch是一次性的，而CyclicBarrier是可以重复利用的。

欢迎关注公众号 山间木匠， 我是小春哥，从事 Java 后端开发，会一点前端、通过持续输出系列技术文章以文会友，如果本文能为您提供帮助，欢迎大家关注、点赞、分享支持，我们下期再见！

posted @ 2020-09-29 09:52 山间木匠阅读(171) 评论(0) 编辑收藏举报

刷新页面返回顶部

山间木匠