【JAVA高级】并发同步工具CyclicBarrier 的使用介绍

执键行天涯

已于 2024-09-06 11:16:00 修改

阅读量1.2k

点赞数 15

分类专栏：多线程 JAVA进阶文章标签： java 开发语言

于 2024-09-05 18:41:44 首次发布

本文链接：https://blog.csdn.net/qq_39666711/article/details/141933316

版权

多线程同时被 2 个专栏收录

19 篇文章 0 订阅

订阅专栏

JAVA进阶

16 篇文章 0 订阅

订阅专栏

📝个人主页🌹：个人主页
⏩收录专栏⏪：JAVA进阶
🌹🌹期待您的关注 🌹🌹，让我们共同进步！
在这里插入图片描述

文章目录

CyclicBarrier 简介

CyclicBarrier 是 Java 中的另一个同步辅助类，它可以让一组线程互相等待，直到所有线程都达到一个屏障点后再继续执行。与
CountDownLatch 不同的是，CyclicBarrier
的计数器可以循环使用，当所有线程都到达屏障点后，计数器会重置，可以被复用。所谓 Cyclic 即循环的意思，所谓 Barrier
即屏障的意思。所以综合起来，CyclicBarrier 指的就是循环屏障，虽然这个叫法很奇怪，但是却能很好地表达其含义

CyclicBarrier 的场景示意图：

单次屏障作用示意：

在这里插入图片描述

循环的屏障作用示意：

在这里插入图片描述

CyclicBarrier 的主要方法包括：

构造方法：CyclicBarrier(int parties) 构造一个 CyclicBarrier 对象，指定参与线程的数量 parties。
await()：让当前线程等待，直到所有参与线程都到达屏障点。

CyclicBarrier 的典型用法包括：

多个线程分阶段执行任务，每个阶段结束后等待其他线程，然后一起执行下一个阶段。
多个线程同时执行不同任务，等待所有任务完成后再进行下一步操作。

CyclicBarrier 使用

案例一：计算10个员工的平均薪资

package com.atguigu.signcenter.nosafe;

import java.util.Set;
import java.util.concurrent.*;

/** 
 * 使用循环栅栏求五个人的平均薪资
 * @author: jd
 * @create: 2024-09-04
 */
public class CyclicBarrierDemo {

    private static final int STUDENT_COUNT =10;
    //存储工人姓名及工资
    private ConcurrentHashMap concurrentHashMap = new ConcurrentHashMap<String,Integer>();
    private ExecutorService executorService =Executors.newFixedThreadPool(10);

    public void avgScore() throws InterruptedException {
        CyclicBarrier  cyclicBarrier =new CyclicBarrier(10);
        for (int i = 0; i < STUDENT_COUNT; i++) {
            executorService.submit(()->{
                //获取工人的工资,这里随机生成工资
                int score = (int) (Math.random() * 3000 + 5000);
                concurrentHashMap.put(Thread.currentThread().getName(),score);
                System.out.println(Thread.currentThread().getName()+"对应的工资为："+score);

                try {
                    //执行完运行 await 等待所有工人的工资都计算完毕
                    cyclicBarrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            });
        }
        Thread.sleep(2000);
        if(cyclicBarrier.getNumberWaiting() ==0){
            int totalNumber = 0;
            Set<String> set =concurrentHashMap.keySet();
            for (String s : set) {
                totalNumber+=(int)concurrentHashMap.get(s);
            }
            System.out.println("五位工人的平均工资为:" + (totalNumber / STUDENT_COUNT) + "元");
        }
        System.out.println("========计算完毕========");
        executorService.shutdown();
    }




    public static void main(String[] args) throws InterruptedException {
        CyclicBarrierDemo cyclicBarrierDemo = new CyclicBarrierDemo();
        cyclicBarrierDemo.avgScore();

    }

}

结果：

pool-1-thread-7对应的工资为：5210
pool-1-thread-3对应的工资为：6376
pool-1-thread-5对应的工资为：7101
pool-1-thread-2对应的工资为：5388
pool-1-thread-10对应的工资为：6609
pool-1-thread-1对应的工资为：5067
pool-1-thread-4对应的工资为：7341
pool-1-thread-8对应的工资为：5228
pool-1-thread-6对应的工资为：6683
pool-1-thread-9对应的工资为：5430
五位工人的平均工资为:6043元
========计算完毕========

案例2：模拟员工都到达公园之后，先表演一个项目

现在要模拟一个所有员工都到达公园之后，进行马拉松比赛的一个过程，等待员工都进行完比赛之后，开始颁奖晚会。

先编写人出发，到公园，首先先表演节目的代码

package com.atguigu.signcenter.nosafe;

import java.util.concurrent.*;

/**
 * 现在要模拟一个所有员工都到达公园之后，进行马拉松比赛的一个过程，等待员工都进行完比赛之后，开始颁奖晚会。
 * 循环屏障演示到达公园，最后的表演一个节目
 * @author: jd
 * @create: 2024-09-05
 */
public class CyclicBarrierDemo2 {
    private static final int PEOPLE_COUNT =10;
    // 创建一个线程池来执行任务
    static final ThreadPoolExecutor executor = new ThreadPoolExecutor(10,20,30L,
            TimeUnit.SECONDS,new LinkedBlockingQueue<Runnable>(),Executors.defaultThreadFactory());

    /**
     * 模拟10个人分别 出发去公园
     */
    public void goParkTogether(){

        CyclicBarrier cyclicBarrier =new CyclicBarrier(10,()->{
            try {
                Thread.sleep(3000);
                System.out.println("因为" + Thread.currentThread().getName() + "最后到我给大家表演一个节目，先解解闷，再开始比赛");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        //启动10个线程，分别模拟十个人出发去公园及在公园路上花费的时间
        for (int i = 0; i < PEOPLE_COUNT; i++) {
            executor.submit(()->{
                try {
                    //模拟路上花费的时间
                    Thread.sleep(2000);
                    System.out.println(Thread.currentThread().getName()+"已经到达");
                    //到屏障了进行等待
                    cyclicBarrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }

            });
        }



    }

    public static void main(String[] args) {
        CyclicBarrierDemo2 cyclicBarrierDemo2 = new CyclicBarrierDemo2();
        cyclicBarrierDemo2.goParkTogether();
    }


}

结果：

pool-1-thread-8已经到达
pool-1-thread-4已经到达
pool-1-thread-3已经到达
pool-1-thread-2已经到达
pool-1-thread-7已经到达
pool-1-thread-10已经到达
pool-1-thread-6已经到达
pool-1-thread-9已经到达
pool-1-thread-1已经到达
pool-1-thread-5已经到达
因为pool-1-thread-5最后到我给大家表演一个节目，再开始比赛

两种写法上稍稍有差异，第一个是通过判断在等待的线程还有没有，如果没有了则执行最后的内容；第二种则是在创建栅栏的时候指定了，等所有线程执行完毕后会执行的内容。

案例3：坐车去春游

本案例我们演示重复使用的场景
重复使用 CyclicBarrier，重复使用是 CyclicBarrier 的特色，这个是 CountDownLatch 不具备的，
我们接着上面的案例演示一下重复使用的案例，小朋友们出游到达动物园后要一起入园，但是小朋友们各自下车的速度不一致，要等大家都到了动物园门口后一起入园。
1. 幼儿园春游坐车只有当小朋友们到齐了才开车出发
2.下车不一致，都下车了再入园

package com.atguigu.signcenter.nosafe;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 本案例我们演示重复使用的场景
 * 重复使用 CyclicBarrier，重复使用是 CyclicBarrier 的特色，这个是 CountDownLatch 不具备的，
 * 我们接着上面的案例演示一下重复使用的案例，小朋友们出游到达动物园后要一起入园，但是小朋友们各自下车的速度不一致，要等大家都到了动物园门口后一起入园。
 * 1. 幼儿园春游 坐车只有当小朋友们到齐了 才开车出发
 * 2.下车不一致，都下车了再入园
 *
 * ————————————————
 * 原文链接：https://blog.csdn.net/weixin_42118323/article/details/137464940
 * @author: jd
 * @create: 2024-09-05
 */
public class CyclicBarrierDemo3 {

    //创建线程池，可以模拟车上的座位
    private ExecutorService executorService = Executors.newFixedThreadPool(10);

    //创建 CyclicBarrier，屏障，每到一个地点的屏障
    CyclicBarrier cyclicBarrier = new CyclicBarrier(5);

    /**
     * 1. 幼儿园春游 坐车只有当小朋友们到齐了 才开车出发；模拟小朋友的上车在车上等待开车前的过程
     * @throws InterruptedException
     */
    public void takeCar() throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            //假设每个小朋友过来需要消耗的时间
            Thread.sleep(1000);
            int finalI = i;
            executorService.execute(() -> {
                System.out.println("第"+(finalI+1)+"上车了，找到了自己的座位并开始等待");
                long starTime = System.currentTimeMillis();
                //执行完运行 await 要等待所有人都到达 await 才可以可以进行下一步
                try {
                    cyclicBarrier.await();
                    System.out.println("同学都上来了，小朋友:" + Thread.currentThread().getName()
                            + "看看了一下自己的 等待时间为:" + (System.currentTimeMillis() - starTime));
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            });

        }

        //模拟都上车之后，清点一下人数，花费3s
        Thread.sleep(3000);
        System.out.println("最后一个小朋友也上来了，我们数一下人数");
        //清点完毕了，准备发车
        System.out.println("=============准备发车============");
    }

    /**
     * 2.下车不一致，都下车了再入园,模拟小朋友的下车过程
     */
    public void admission() throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            //假设小朋友下车需要消耗的时间
            Thread.sleep(1000);
            int finalI = i;
            executorService.execute(()->{
                System.out.println("第"+(finalI+1)+"下车了，找到了到了公园门口并开始等待");
                long starTime = System.currentTimeMillis();
                //执行完运行 await 要等待所有人都到达 await 才可以可以进行下一步
                try {
                    cyclicBarrier.await();
                    System.out.println("小朋友:" + Thread.currentThread().getName()
                            + "已经下车到达公园门口,等待入园,看一下下车花费时间时间为:" + (System.currentTimeMillis() - starTime));
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            });

        }
        //模拟整理一下队伍花费的时间，花费3s
        Thread.sleep(3000);
        System.out.println("最后一个下小朋友下车比较慢，我们等一下");
        //整理完毕后，准备入园
        System.out.println("=======最后一个小朋友也下来了，小朋友们都下车了，准备入园=======");
        //同学们都入园了，车也准备撤退了。
        executorService.shutdown();
    }


    public static void main(String[] args) throws InterruptedException {
        CyclicBarrierDemo3 cyclicBarrierDemo3 = new CyclicBarrierDemo3();
        //1. 幼儿园春游 坐车只有当小朋友们到齐了 才开车出发；模拟小朋友的上车在车上等待开车前的过程
        cyclicBarrierDemo3.takeCar();
        //2.下车不一致，都下车了再入园,模拟小朋友的下车过程
        cyclicBarrierDemo3.admission();

    }



}

结果：

第1上车了，找到了自己的座位并开始等待
第2上车了，找到了自己的座位并开始等待
第3上车了，找到了自己的座位并开始等待
第4上车了，找到了自己的座位并开始等待
第5上车了，找到了自己的座位并开始等待
同学都上来了，小朋友:pool-1-thread-1看看了一下自己的 等待时间为:4020
同学都上来了，小朋友:pool-1-thread-4看看了一下自己的 等待时间为:1000
同学都上来了，小朋友:pool-1-thread-3看看了一下自己的 等待时间为:2003
同学都上来了，小朋友:pool-1-thread-2看看了一下自己的 等待时间为:3004
同学都上来了，小朋友:pool-1-thread-5看看了一下自己的 等待时间为:0
最后一个小朋友也上来了，我们数一下人数
=============准备发车============
第1下车了，找到了到了公园门口并开始等待
第2下车了，找到了到了公园门口并开始等待
第3下车了，找到了到了公园门口并开始等待
第4下车了，找到了到了公园门口并开始等待
第5下车了，找到了到了公园门口并开始等待
小朋友:pool-1-thread-6已经下车到达公园门口,等待入园,看一下下车花费时间时间为:4020
小朋友:pool-1-thread-7已经下车到达公园门口,等待入园,看一下下车花费时间时间为:3014
小朋友:pool-1-thread-9已经下车到达公园门口,等待入园,看一下下车花费时间时间为:1008
小朋友:pool-1-thread-8已经下车到达公园门口,等待入园,看一下下车花费时间时间为:2010
小朋友:pool-1-thread-10已经下车到达公园门口,等待入园,看一下下车花费时间时间为:0
最后一个下小朋友下车比较慢，我们等一下
=======最后一个小朋友也下来了，小朋友们都下车了，准备入园=======

案例4：集齐7颗龙珠召唤神龙

CyclicBarrier的字面意思是可循环（Cyclic）使用的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。线程进入屏障通过CyclicBarrier的await()方法。（CyclicBarrier与CountDownLatch相反，CountDownLatch是加，CyclicBarrier是减）

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        // CyclicBarrier(int parties, Runnable barrierAction)
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> System.out.println("召唤神龙"));
        for (int i = 1; i < 8; i++) {
            int finalI = i;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "\t收集到第" + finalI + "颗龙珠");
                try {
                    cyclicBarrier.await();  
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }, "Thread" + i).start();
        }
    }
}