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

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

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

对于部分业务需要多次循环使用,就可以使用本章节的 CyclicBarrierCyclicBarrier的字面意思是可循环使用(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 构造函数中的任务,执行完毕后退出屏障点,继续向下运行。

CyclicBarrierCountDownLatch区别

CyclicBarrierCountDownLatch可能容易混淆,我们强调下它们的区别。

  • CountDownLatch的参与线程是有不同角色的,有的负责倒计时,有的在等待倒计时变为 0,负责倒计时和等待倒计时的线程都可以有多个,用于不同角色线程间的同步。

  • CyclicBarrier的参与线程角色是一样的,用于同一角色线程间的协调一致。

  • CountDownLatch是一次性的,而CyclicBarrier是可以重复利用的。


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

在这里插入图片描述

©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页