多线程与高并发之CyclicBarrier

最新推荐文章于 2022-10-27 17:43:57 发布
最新推荐文章于 2022-10-27 17:43:57 发布
阅读量344 收藏
点赞数
分类专栏： 多线程与高并发 文章标签： java 多线程 并发编程 多进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiangzhou556/article/details/106399632
版权

多线程与高并发之CyclicBarrier

​ CyclicBarrier主要用于实现，当某一个线程需要等待其他多个线程执行完某些操作之后才开始执行。CyclicBarrier初始化了一个基数的数量，然后各个线程执行完某些操作之后，调用await方法进入等待状态，当等待的进程数量等于初始化的数量的时候，所有的线程将重新激活继续执行。CycliBarrier就跟名字一样他就是各个线程的障碍，只有全部线程到齐之后才能跨过这个障碍。

需求背景

10个运动员，不同时间到体育场比赛，所有运动员到了之后就开始比赛，最后模拟各个赛道的运动员的最终成绩

实现设计

  1. 创建一个运动员类（Sportsman）有姓名、赛道、CyclicBarrier对象等几个属性

  2. 运动员线程都是先到达体育场，进行热身。所有运动员到了之后开始鸣枪开始

  3. 最后统计各个赛道运动员的成绩

代码实现

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierTest {
    public static void main(String[] args) {
        //假设有8个赛道
        String[] sportmans = {"博尔特", "鲍威尔", "加特林", "盖伊", "布雷克", "格林", "波尔顿", "罗杰斯"};
        //1.定义cyclicBarrier对象，定义有几个参与者，同时可以使用第二参数来输出输出是否全部运动元已经到场
        CyclicBarrier cyclicBarrier = new CyclicBarrier(8, new Runnable() {
            @Override
            public void run() {
                System.out.println("8位运动员都已经全部到场，比赛开始......");
            }
        });
        for (int i = 1; i <= 8; i++) {
            //初始化运动员对象，请启动线程
            new Thread(new Sportsman(sportmans[i - 1], i + "", cyclicBarrier)).start();
        }

    }

}

class Sportsman implements Runnable {

    /**
     * 姓名
     */
    String name;
    /**
     * 跑道
     */
    String track;

    //计数器屏障对象，所有运动员到场之后才能开始鸣枪
    CyclicBarrier cyclicBarrier;

    public Sportsman(String name, String track, CyclicBarrier cyclicBarrier) {
        this.name = name;
        this.track = track;
        this.cyclicBarrier = cyclicBarrier;
    }

    @Override
    public void run() {
        System.out.println("第【" + this.track + "】赛道的【" + this.name + "】已经到场，正在热身");
        try {
            //等待其他到场准备
            cyclicBarrier.await();
            //模拟运动员100的时间，全部运动员都是高手，所有这边模式成绩都是在9-10秒之间
            double time = Math.random();
            time = 9 + time;
            BigDecimal bg = new BigDecimal(time).setScale(2, RoundingMode.HALF_DOWN);
            Thread.sleep(bg.multiply(new BigDecimal(1000)).intValue());
            System.out.println("第【" + this.track + "】赛道的【" + this.name + "】完成比赛，比赛时间：" + bg.toString() + "s");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }

    }
}

代码的执行效果如下：

第【1】赛道的【博尔特】已经到场，正在热身
第【5】赛道的【布雷克】已经到场，正在热身
第【3】赛道的【加特林】已经到场，正在热身
第【4】赛道的【盖伊】已经到场，正在热身
第【2】赛道的【鲍威尔】已经到场，正在热身
第【7】赛道的【波尔顿】已经到场，正在热身
第【6】赛道的【格林】已经到场，正在热身
第【8】赛道的【罗杰斯】已经到场，正在热身
8位运动员都已经全部到场，比赛开始......
第【1】赛道的【博尔特】完成比赛，比赛时间：9.03s
第【2】赛道的【鲍威尔】完成比赛，比赛时间：9.05s
第【7】赛道的【波尔顿】完成比赛，比赛时间：9.12s
第【8】赛道的【罗杰斯】完成比赛，比赛时间：9.19s
第【4】赛道的【盖伊】完成比赛，比赛时间：9.24s
第【6】赛道的【格林】完成比赛，比赛时间：9.40s
第【5】赛道的【布雷克】完成比赛，比赛时间：9.81s
第【3】赛道的【加特林】完成比赛，比赛时间：9.86s

扩展需求

如果这个时候我们需要得到最后所有运动员的排名以及对应的成绩，我们如何实现？

这个时候我们可以结合countdownlatch计数器来实现，在每个运动员对象中新增一个CountDownLatch对象，同时新增裁判对象，用于记录所有运动员所有成绩，并在比赛结束的时候公布最后结果.

修改后第代码

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.*;
import java.util.stream.Collectors;

public class CyclicBarrierTest {
    public static void main(String[] args) throws Exception {
        //假设有8个赛道
        String[] sportmanNames = {"博尔特", "鲍威尔", "加特林", "盖伊", "布雷克", "格林", "波尔顿", "罗杰斯"};
        List<Sportsman> sportsmanList = new ArrayList<Sportsman>();
        BigDecimal[] scores = new BigDecimal[8];
        //1.定义cyclicBarrier对象，定义有几个参与者，同时可以使用第二参数来输出输出是否全部运动元已经到场
        CyclicBarrier cyclicBarrier = new CyclicBarrier(8, new Runnable() {
            @Override
            public void run() {
                System.out.println("8位运动员都已经全部到场，比赛开始......");
            }
        });
        CountDownLatch countDownLatch = new CountDownLatch(8);
        for (int i = 1; i <= 8; i++) {
            //初始化运动员对象，请启动线程
            Sportsman sportsman = new Sportsman(sportmanNames[i - 1], i + "", cyclicBarrier, countDownLatch);
            new Thread(sportsman).start();
            sportsmanList.add(sportsman);
        }
        Judge judge = new Judge(countDownLatch);
        judge.sportsmanList = sportsmanList;
        new Thread(judge).start();


    }

}

class Judge implements Runnable {
    CountDownLatch countDownLatch;
    List<Sportsman> sportsmanList;

    public Judge(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        System.out.println("裁判就位....");
        try {
            countDownLatch.await();
            System.out.println("比赛结束，等待裁判公布最后成绩.....");
            sportsmanList = sportsmanList.stream().sorted(Comparator.comparing(Sportsman::getScore))
                    .collect(Collectors.toList());
            int i = 0;
            for (Sportsman sportsman : sportsmanList) {
                System.out.println("第【" + (i+1) + "】名-->" + "第【" + sportsmanList.get(i).track + "】赛道的【" + sportsmanList.get(i).name + "】完成比赛，比赛时间：" + sportsmanList.get(i).score + "s");
                i++;
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

class Sportsman implements Runnable {
    /**
     * 姓名
     */
    String name;
    /**
     * 跑道
     */
    String track;

    //计数器屏障对象，所有运动员到场之后才能开始鸣枪
    CyclicBarrier cyclicBarrier;

    CountDownLatch countDownLatch;

    BigDecimal score;

    public BigDecimal getScore() {
        return score;
    }

    public Sportsman(String name, String track, CyclicBarrier cyclicBarrier, CountDownLatch countDownLatch) {
        this.name = name;
        this.track = track;
        this.cyclicBarrier = cyclicBarrier;
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        System.out.println("第【" + this.track + "】赛道的【" + this.name + "】已经到场，正在热身");
        try {
            //等待其他到场准备
            cyclicBarrier.await();
            //模拟运动员100的时间，全部运动员都是高手，所有这边模式成绩都是在9-10秒之间
            double time = Math.random();
            time = 9 + time;
            score = new BigDecimal(time).setScale(2, RoundingMode.HALF_DOWN);
            Thread.sleep(score.multiply(new BigDecimal(1000)).intValue());
            System.out.println("第【" + this.track + "】赛道的【" + this.name + "】完成比赛，比赛时间：" + score.toString() + "s");

        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        } finally {
            countDownLatch.countDown();
        }

    }

}

看看这个时候的运行结果：

裁判就位....
第【1】赛道的【博尔特】已经到场，正在热身
第【2】赛道的【鲍威尔】已经到场，正在热身
第【3】赛道的【加特林】已经到场，正在热身
第【4】赛道的【盖伊】已经到场，正在热身
第【5】赛道的【布雷克】已经到场，正在热身
第【6】赛道的【格林】已经到场，正在热身
第【7】赛道的【波尔顿】已经到场，正在热身
第【8】赛道的【罗杰斯】已经到场，正在热身
8位运动员都已经全部到场，比赛开始......
第【2】赛道的【鲍威尔】完成比赛，比赛时间：9.30s
第【5】赛道的【布雷克】完成比赛，比赛时间：9.51s
第【8】赛道的【罗杰斯】完成比赛，比赛时间：9.54s
第【7】赛道的【波尔顿】完成比赛，比赛时间：9.81s
第【6】赛道的【格林】完成比赛，比赛时间：9.83s
第【1】赛道的【博尔特】完成比赛，比赛时间：9.90s
第【3】赛道的【加特林】完成比赛，比赛时间：9.91s
第【4】赛道的【盖伊】完成比赛，比赛时间：9.93s
比赛结束，等待裁判公布最后成绩.....
第【1】名-->第【2】赛道的【鲍威尔】完成比赛，比赛时间：9.30s
第【2】名-->第【5】赛道的【布雷克】完成比赛，比赛时间：9.51s
第【3】名-->第【8】赛道的【罗杰斯】完成比赛，比赛时间：9.54s
第【4】名-->第【7】赛道的【波尔顿】完成比赛，比赛时间：9.81s
第【5】名-->第【6】赛道的【格林】完成比赛，比赛时间：9.83s
第【6】名-->第【1】赛道的【博尔特】完成比赛，比赛时间：9.90s
第【7】名-->第【3】赛道的【加特林】完成比赛，比赛时间：9.91s
第【8】名-->第【4】赛道的【盖伊】完成比赛，比赛时间：9.93s
jiangzhou556
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发编程系列05:CyclicBarrier+Runnable，实现线程安全
fen_fen的专栏
11-22 763
CyclicBarrier CyclicBarrier的字面意思是可循环（Cyclic）使用的屏障(Barrier)，它要做的事情是，让一组线程到达一个屏障(也可以叫同步点)时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活，线程进入屏障通过CyclicBarrier的await()方法。 CountDownLatch是一个同步的辅助类，允许一个或多个线程，等待其他一组线程完成操作，再继续执行。 CyclicBarrier是一个同步的辅助类，允许一组线程相互之间等待，
Java并发工具之CyclicBarrier
weixin_41951205的博客
02-28 1972
一、简介 摘自《Java并发编程的艺术》一书中 CyclicBarrier的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。 CyclicBarrier，一个同步辅助类，在API中是这么介绍的： 它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，
Java CyclicBarrier 循环屏障的源码深度解析与应用
终生学习践行者
08-17 2449
详细介绍了CyclicBarrier循环屏障的原理和应用，以及与CountDownLatch的对比！
Java基础—循环栅栏CyclicBarrier
m0_72882572的博客
10-27 469
CyclicBarrier特别适用于并行迭代计算，每个线程负责一部分计算，然后在栅栏处等待其他线程完成，所有线程到齐后，交换数据和计算结果，再进行下一次迭代。 与CountDownLatch类似，它也有一个数字，但表示的是参与的线程个数，这个数字通过构造方法进行传递：
CyclicBarrier的简单理解
joenqc的博客
08-10 585
CyclicBarrier的概念字面翻译为回环栅栏，同CountDownLatch一样，也是concurrent包中提供的多线程之间通信的一种方式。它允许一组线程在等待某个状态后再全部同时执行。它允许一组线程互相等待对方，直到到达一个公共障碍点(barrier point)。它的一个典型应用是一组固定个数的线程需要互相等待，直到全部执行完成后，再继续执行。之所以称为Cyclic，是因为所有等待线程被
多线程与高并发编程笔记、源码等
09-05
标题“多线程与高并发编程笔记、源码等”表明了资源的核心内容，涵盖了多线程和高并发编程的理论与实践。多线程允许一个应用程序同时执行多个任务，而高并发则指系统能够处理大量并发请求的能力。这两个概念在现代...
人工智能-项目实践-多线程-多线程与高并发.zip
01-04
在这个名为"人工智能-项目实践-多线程-多线程与高并发.zip"的压缩包中，我们可以推测它可能包含了关于如何在AI项目中应用多线程技术以实现高效并发处理的资源，比如代码示例、教程或者研究报告。 多线程是指在一个...
Java多线程与并发库视频资源网盘链接
04-11
Java多线程与并发库是Java开发者必备的重要技能之一，尤其对于处理高并发场景的应用开发至关重要。本视频资源集合旨在帮助初级开发人员深入理解和掌握这一关键领域，通过学习，你可以提升自己的程序性能优化能力，更...
java线程并发cyclicbarrier类使用示例
09-04
Java中的`CyclicBarrier`是用于多线程同步的一个强大工具，主要应用于一组线程需要在继续执行之前等待其他线程到达某个特定点的情况。它允许开发者定义一个屏障点，只有当所有参与的线程都到达这个屏障点时，它们才...
人工智能-项目实践-多线程-Java多线程高并发实例.zip
最新发布
01-04
在本项目实践中，我们将深入探讨Java中的多线程与高并发技术，特别是在人工智能领域的应用。Java作为一种广泛应用的编程语言，其强大的并发处理能力是其在大规模数据处理和高性能计算场景中备受青睐的原因之一。本...
Java并发编程（CyclicBarrier）实例详解
08-29
主要介绍了Java并发编程（CyclicBarrier）实例详解的相关资料，JAVA编写并发程序的时候，我们需要仔细去思考一下并发流程的控制，如何让各个线程之间协作完成某项工作。
Java并发编程之CyclicBarrier详解
热门推荐
Stay Hungry, Stay Foolish
06-03 6万+
简介栅栏类似于闭锁，它能阻塞一组线程直到某个事件的发生。栅栏与闭锁的关键区别在于，所有的线程必须同时到达栅栏位置，才能继续执行。闭锁用于等待事件，而栅栏用于等待其他线程。CyclicBarrier可以使一定数量的线程反复地在栅栏位置处汇集。当线程到达栅栏位置时将调用await方法，这个方法将阻塞直到所有线程都到达栅栏位置。如果所有线程都到达栅栏位置，那么栅栏将打开，此时所有的线程都将被释放，而栅栏...
CyclicBarrie（循环栅栏）的作用与用法
狗狗大蛇
11-08 1759
CyclicBarrie的作用与用法 一、CyclicBarrie的作用 CyclicBarrier循环栅栏（循环屏障）是一个多线程同步的辅助工具类，它允许一组线程在到达某个等待屏障点(common barrier point)互相等待，发生阻塞，直到最后一个线程到达等待屏障点，屏障才会打开，之前处于阻塞状态的线程才能恢复继续执行.它非常适用于一组线程之间必需经常互相等待的情况。 CyclicBarrier从字面理解是循环的栅栏，之所以称之为循环的是因为在等待线程释放后，该栅栏还可以复用。后面我们代码中会进
java循环栅栏CyclicBarrier 使用详解
cputao的博客
12-02 3076
1. CyclicBarrier 是什么？ 从字面上的意思可以知道，这个类的中文意思是“循环栅栏”。大概的意思就是一个可循环利用的屏障。 它的作用就是会让所有线程都等待完成后才会继续下一步行动。 举个例子，就像生活中我们会约朋友们到某个餐厅一起吃饭，有些朋友可能会早到，有些朋友可能会晚到，但是这个餐厅规定必须等到所有人到齐之后才会让我们进去。这里的朋友们就是各个线程，餐厅就是 CyclicBarrier。 2. 怎么使用 CyclicBarrier...
新Java并发线程控制：CyclicBarrier等待所有线程到达一个状态后再让全部线程处于一个起跑线（1）
Zhang Phil
10-29 1384
新Java并发线程控制：CyclicBarrier等待所有线程到达一个状态后再让全部线程处于一个起跑线（1） Java批量线程运行后，有的运行慢，有的运行快，CyclicBarrier让所有线程到达一定状态后继续接着执行。举一个龟兔赛跑的例子，兔子很快就可以到400米赛点，而乌龟跑的慢，很慢才到。现在要求兔子和乌龟必须都到达400米赛点时候才可以重启赛跑。CyclicBarrier的await(...
多线程之CountDownLatch和CyclicBarrier的区别和用法
我是个少年的博客
12-05 5483
一.CountDownLatch的使用 CountDownLatch经常用于监听某些初始化操作，等初始化执行完毕后，再通知主线程继续工作。 CountDownLatch定义： 一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，awai
CyclicBarrier循环屏障使用案例
qq_40506747的博客
03-04 282
CyclicBarrier与CountDownLatch功能类似，都带有计数阻塞功能。关于CountDownLatch的讲解案例 CountdownLatch阻塞主线程，等所有子线程完结了再继续下去。Syslicbarrier阻塞一组子线程，直至某个状态之后再全部同时执行（一般为子线程数量达到预期值）。并且所有线程都被释放后，还能通过reset来重用。 CyclicBarrier通过 cyclicBarrier.await(); 方法对子线程进行拦截。所以，业务逻辑在await() 前后就有两种完全不同的执
Java多线程/并发23、循环屏障CyclicBarrier
程序老兵的博客
05-04 1602
CyclicBarrier 直译叫循环屏障或循环分界点。让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续工作。打个比方，F1大奖赛共5支车队参赛。第一站：上海站。比赛马上要开始了，各个车队都在准备，但是先到达起跑线准备就绪的车队没法开始比赛，必须等待。只有当5支车队都到达起跑线准备就绪后，裁判才可以发起比赛。这5个车队到达起跑线
线程安全（九）CyclicBarrier
relife
06-22 354
0.前言 障碍器类，循环栅栏 看过源码。此工具类依靠Condition和ReetrantLock实现了屏障功能，当所有子任务执行完成，屏障解除，下一任务才会继续，而且屏障会恢复。 1.源码解析 1.1.属性 // 可重入锁 private final ReentrantLock lock = new ReentrantLock(); /** Condition to wait on until tripped */ // 条件 private final Conditi

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值