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

news2024/9/21 12:32:41

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

文章目录

- CyclicBarrier 简介
- CyclicBarrier 的场景示意图：
- - 单次屏障作用示意：
  - 循环的屏障作用示意：
- CyclicBarrier 的主要方法包括：
- CyclicBarrier 使用

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最后到我给大家表演一个节目，再开始比赛