jdk-CyclicBarrier(二)

最新推荐文章于 2020-07-26 15:27:23 发布
最新推荐文章于 2020-07-26 15:27:23 发布
阅读量242 收藏
点赞数
分类专栏： jdk
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32924343/article/details/73548408
版权

jdk-CyclicBarrier这一篇主要是分析了它 的源码和运行图。这一篇来看看怎么运用，毕竟都是要使用的。

上文在分析源码过程中发现有个代数的问题，在nextGeneration中会有下一代的出现，这个是否就是说它是可以重用的？不然哪会来区分一代，二代，三代呢？

例子1：次例子中重复使用了CyclicBarrier

public class TestCycB {

    private static int num = 3;

    public static void main(String[] args) throws Exception{

        final CyclicBarrier cb = new CyclicBarrier(num);

        for(int i = 0; i < 3; i ++){
            new EachThread(cb).start();
        }
        Thread.sleep(10000);
        System.out.println("主线程休息够了，燥起来");

        for(int i = 0; i < 3; i ++){
            new EachThread(cb).start();
        }

    }
}

class EachThread extends Thread{

    private CyclicBarrier cb;

    public EachThread(CyclicBarrier cb){
        this.cb = cb;
    }

    @Override
    public void run() {
        try{
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName()+"进入等待");
            cb.await();
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName()+"等待结束了，执行起来");
        }catch (InterruptedException e){
            e.printStackTrace();
        }catch (BrokenBarrierException e1){
            e1.printStackTrace();
        }
    }

}

Thread-0进入等待
Thread-2进入等待
Thread-1进入等待
Thread-1等待结束了，执行起来
Thread-0等待结束了，执行起来
Thread-2等待结束了，执行起来
主线程执行
Thread-3进入等待
Thread-5进入等待
Thread-4进入等待
Thread-4等待结束了，执行起来
Thread-3等待结束了，执行起来
Thread-5等待结束了，执行起来

例子2，使用timeout，timeout是指虽然全部线程没有完全进入，但是超过这个超时时间的话，立马执行其余线程,这些线程会抛出异常，然后继续执行. 

public class TestCycB {

    private static int num = 3;

    public static void main(String[] args) throws Exception{

        final CyclicBarrier cb = new CyclicBarrier(num);

        for(int i = 0; i < 3; i ++){
            Thread.sleep(3000);
            new EachThread(cb).start();
        }
    }
}

class EachThread extends Thread{

    private CyclicBarrier cb;

    public EachThread(CyclicBarrier cb){
        this.cb = cb;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"进入初始化");
        try{
            Thread.sleep(2000);//模拟初始化
            System.out.println(Thread.currentThread().getName() + "初始化结束，进入等待");
            cb.await(3, TimeUnit.SECONDS);  //睡3
        }catch (InterruptedException e){
            e.printStackTrace();
        }catch (BrokenBarrierException e1){
            e1.printStackTrace();
        }catch (TimeoutException e2){
            e2.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"等待结束了，执行起来");
    }

}


Thread-0进入初始化
Thread-0初始化结束，进入等待
Thread-1进入初始化
java.util.concurrent.TimeoutException
Thread-1初始化结束，进入等待
	at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
Thread-0等待结束了，执行起来
	at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:427)
Thread-1等待结束了，执行起来
	at concurrenttest.EachThread.run(TestCycB.java:40)
java.util.concurrent.BrokenBarrierException
	at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:243)
	at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:427)
	at concurrenttest.EachThread.run(TestCycB.java:40)
Thread-2进入初始化
java.util.concurrent.BrokenBarrierException
	at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:200)
	at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:427)
	at concurrenttest.EachThread.run(TestCycB.java:40)
Thread-2初始化结束，进入等待
Thread-2等待结束了，执行起来

例子3，自定义任务，自定义任务的执行是由最终进入的线程执行的，源码中可以看见，并且这个任务是优先于其他等待线程. 
public class TestCycB {

    private static int num = 3;

    public static void main(String[] args) throws Exception{

        final CyclicBarrier cb = new CyclicBarrier(num,new Runnable() {
            @Override
            public void run() {
                try{
                Thread.sleep(5000);
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"自带任务的执行");
            }
        });

        for(int i = 0; i < 3; i ++){
            new EachThread(cb).start();
        }
    }
}

class EachThread extends Thread{

    private CyclicBarrier cb;

    public EachThread(CyclicBarrier cb){
        this.cb = cb;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"进入初始化");
        try{
            Thread.sleep(2000);//模拟初始化
            System.out.println(Thread.currentThread().getName() + "初始化结束，进入等待");
            cb.await();
        }catch (InterruptedException e){
            e.printStackTrace();
        }catch (BrokenBarrierException e1){
            e1.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"等待结束了，执行起来");
    }

}

Thread-0进入初始化
Thread-2进入初始化
Thread-1进入初始化
Thread-0初始化结束，进入等待
Thread-2初始化结束，进入等待
Thread-1初始化结束，进入等待
Thread-2自带任务的执行
Thread-0等待结束了，执行起来
Thread-1等待结束了，执行起来
Thread-2等待结束了，执行起来

例子4: 可以发现自带任务先执行完，最后才指向其他任务。 

public class TestCycB {

    private static int num = 3;

    public static void main(String[] args) throws Exception{

        final CyclicBarrier cb = new CyclicBarrier(num,new Runnable() {
            @Override
            public void run() {
                try{
                    Thread.sleep(10000);
                }catch (Exception e){
                    e.printStackTrace();
                }

                System.out.println("自带任务执行了");
            }
        });

        for(int i = 0; i < 3; i ++){
            new EachThread(cb).start();
        }
    }
}

class EachThread extends Thread{

    private CyclicBarrier cb;

    public EachThread(CyclicBarrier cb){
        this.cb = cb;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"进入初始化");
        try{
            System.out.println(Thread.currentThread().getName() + "初始化结束，进入等待");
            cb.await(1, TimeUnit.SECONDS);  //睡3
        }catch (InterruptedException e){
            e.printStackTrace();
        }catch (BrokenBarrierException e1){
            e1.printStackTrace();
        }catch (TimeoutException e2){
            e2.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"等待结束了，执行起来");
    }

}

Thread-2进入初始化
Thread-2初始化结束，进入等待
Thread-1进入初始化
Thread-1初始化结束，进入等待
Thread-0进入初始化
Thread-0初始化结束，进入等待
自带任务执行了
Thread-0等待结束了，执行起来
Thread-2等待结束了，执行起来
Thread-1等待结束了，执行起来


例子5：自带任务抛异常。 
public class TestCycB {

    private static int num = 3;

    public static void main(String[] args) throws Exception{

        final CyclicBarrier cb = new CyclicBarrier(num,new Runnable() {
            @Override
            public void run() {
                try{
                    Thread.sleep(6000);
                    System.out.println("自带任务执行了:抛异常");
                    int j = 1 /0;
                }catch (Exception e){
                    e.printStackTrace();
                }


            }
        });

        for(int i = 0; i < 3; i ++){
            new EachThread(cb).start();
        }
    }
}

class EachThread extends Thread{

    private CyclicBarrier cb;

    public EachThread(CyclicBarrier cb){
        this.cb = cb;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"进入初始化");
        try{
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + "初始化结束，进入等待");
            cb.await();  //睡3
        }catch (InterruptedException e){
            e.printStackTrace();
        }catch (BrokenBarrierException e1){
            e1.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"等待结束了，执行起来");
    }

}


Thread-0进入初始化
Thread-2进入初始化
Thread-1进入初始化
Thread-2初始化结束，进入等待
Thread-0初始化结束，进入等待
Thread-1初始化结束，进入等待
自带任务执行了:抛异常
Thread-1等待结束了，执行起来
Thread-2等待结束了，执行起来
Thread-0等待结束了，执行起来
java.lang.ArithmeticException: / by zero
	at concurrenttest.TestCycB$1.run(TestCycB.java:25)
	at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:213)
	at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:355)
	at concurrenttest.EachThread.run(TestCycB.java:54)

最后来比较下CountDownLatch和CyclicBarrier的一些不同点。。

拿赛跑来说吧，这是个比较典型的例子。

场景1：5个人赛跑，还有一个裁判，当裁判说开始时，5个人起跑，当某一个人到达终点后，裁判按一下计数器，直至最后一个人到达，最后裁判才开始统计时间，得到每个人的时间。这个就是CountDownLatch的运用。

场景2：还是5个人赛跑，这一次没有裁判了，只规定如果5个人到达终点后，一起去喝酒这个就是CyclicBarrier的运用，此例子中没有说是否需要一起起跑，如果需要，可以加上CountDownLatch。

CountDownLatch就是一个线程等待其他线程都完成之后，再执行某些事情，强调这个。

CyclicBarrier强调线程互相等待，等待全部完成。



刘二郎
关注
专栏目录
jdk-6u45-linux-x64.bin
10-27
这个二进制文件是一个可执行的压缩包，用于在Linux系统上安装JDK 1.6。 JDK 1.6是Java的一个重要版本，它引入了许多新特性、增强功能和错误修复。以下是该版本的一些关键知识点： 1. **泛型类型安全**：JDK 1.6...
jdk-1_5_0_22-windows-amd64
06-01
同时，针对多线程编程，加入了并发工具类，如`java.util.concurrent`包，提供了更高级别的同步机制，如CyclicBarrier和CountDownLatch，帮助开发者更高效地编写并发程序。 AMD64架构，是AMD公司推出的一种64位计算...
常用的并发工具类(2)CyclicBarrier
不吃鱼的猫
01-13 156
用法：让一组线程达到某个屏障，一起被阻塞，一直到组内最后一个线程达到屏障时，屏障开放，所有被阻塞的线程会继续运行CyclicBarrier(int parties) 另一个构造函数：CyclicBarrier(int parties, Runnable barrierAction)，屏障开放，barrierAction定义的任务会执行 样例： import java.util.Map;...
java并发编程之CyclicBarrier
赵崇
07-24 595
CyclicBarrier提供2个构造器：//@param parties指让多少个线程或者任务等待至barrier状态； //@param barrierAction为当这些线程都达到barrier状态时会执行的内 public CyclicBarrier(int parties, Runnable barrierAction) { } //@param parties指让多少个线程或者任务等待至
2.2 CyclicBarrier的理解和使用
一点光辉的博客
06-14 250
package cn.enjoyedu.ch2.tools; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.CyclicBarrier; /** *类说明：演示CyclicBarrier用法,共4个子线程，他们全部完成工作后，交出自己结果， *再被统一释放去做自己的事情，而交出的结果被另外的线程拿来拼接字符串 */ public class UseC.
JUC框架 CyclicBarrier源码解析 JDK8
anlian523的博客
06-21 939
CyclicBarrier类似于CountDownLatch但又不同，在CyclicBarrier里，每个线程既要CountDown减小计数器，也要阻塞等待直到count为0（即等待线程到齐）。 CyclicBarrier基于独占锁和条件队列而实现。 CyclicBarrier可以重复使用，每有parties个线程到达barrier，开启新的一代。然后旧的一代线程就会相继从CyclicBarrier#await退出。 CyclicBarrier实现了all-or-none breakage model的原则
CyclicBarrier2种用法【java多线程】
许欢的博客
01-24 343
CyclicBarrier 一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。 CyclicBarrier 支持一个可选的 Runnabl...
jdk-CyclicBarrier(一)
lwgzj的博客
06-21 281
CyclicBarrier有点类似CountDownLatch，貌似都是个倒数计数器，这里暂且不去管异同点，先把CyclicBarrier分析完，应该就能知道不同了。 //标志是否当前代，当前代我是这么理解的，每一次对象的生成就属于一代(个人观点) private static class Generation { boolean broken = false;
JDK源码分析-CyclicBarrier
WriteOnRead
07-05 184
概述CyclicBarrier 是并发包中的一个工具类，它的典型应用场景为：几个线程执行完任务后，执行另一个线程（回调函数，可选），然后继续下一轮，如此往复。打个通俗的比...
【JDK】JDK源码分析-CyclicBarrier
weixin_38166686的博客
08-08 88
概述 CyclicBarrier 是并发包中的一个工具类，它的典型应用场景为：几个线程执行完任务后，执行另一个线程（回调函数，可选），然后继续下一轮，如此往复。 打个通俗的比方，可以把 CyclicBarrier 的执行流程比作：几个人（类比线程）围着操场跑圈，所有人都到达终点后（终点可理解为“屏障（barrier）”，到达次序可能有先后，对应线程执行任务有快慢），执行某...
Concurrent -- 06 -- CyclicBarrier源码解析
Gene Xu
07-26 203
CyclicBarrier，即循环栅栏，是一个同步工具类，用于阻塞当前线程，等待其他线程，所有线程都必须同时到达栅栏位置后，才可以继续执行 当所有线程都达到栅栏位置后，可以触发执行一个预先设置好的任务 一、内部类解析 Generation private static class Generation { // 标记当前代是否损坏 boolean broken = false; } Generation 是 CyclicBarrier 的内部类，用于帮助 CyclicBarrie
java-jdk1.6-jdk-6u45-windows-x64.zip
最新发布
11-15
4. 并发工具：提供了一些新的并发工具类，如`java.util.concurrent`包下的`CountDownLatch`、`CyclicBarrier`和`Phaser`，这些工具帮助开发者更高效地管理多线程程序。 5. JDBC增强：JDBC API进行了扩展，增加了对...
jdk-6u41-linux-x64 64位
03-12
"jdk-6u41-linux-x64.bin"是一个二进制安装文件，用于在64位Linux系统上安装JDK 6u41。安装通常涉及变更文件权限，然后执行该二进制文件，按照提示进行安装。安装完成后，开发人员可以设置`JAVA_HOME`环境变量，将...
jdk-8u241-windows-x64.rar
05-26
9. **并发改进**：JDK 8在并发方面也有所提升，如Fork/Join框架的改进，以及CountDownLatch、CyclicBarrier等并发工具类的优化。 安装"jdk-8u241-windows-x64.exe"时，通常需要遵循以下步骤： 1. 下载并解压压缩包...
Object源码分析（一）-- clone方法
lwgzj的博客
09-05 4744
java基类Object 在你编写一个类的时候，若无指定父类（没有显式extends一个父类）编译器（一般编译器完成该步骤）会默认的添加Object为该类的父类（可以将该类反编译看其字节码，不过貌似Java7自带的反编译javap现在看不到了）。  　　再说的详细点：假如类A，没有显式继承其他类，编译器会默认添加Object为其父类；若有，那么那个显式父类呢？要么是没有显式继承，那么Objec
Object源码分析（二）-- hashcode方法
lwgzj的博客
09-22 1806
Object内还有一个hashcode方法，留给子类实现的，但是本身Object的hashcode方法也是可以返回一串hash值的，但是是基于C++写的，本人表示看不懂~~。贴几个博客留待研究吧，表示确实不清楚是怎么得到，需要去研究C++去了。暂时读不懂.http://blog.csdn.net/luanlouis/article/details/41547649http://blog.csdn....
jdk-ThreadPoolExecutor(二)---内部参数和拒绝策略
lwgzj的博客
06-26 1080
承继上一篇，上一篇主要分析了下ThreadPoolExecutor中的大概执行逻辑，这一篇主要分析一下内部参数的写一写测试程序。 首先来看里面的最终的默认构造方法，分析其参数,以及其流程 //Executors中的四个构造方法最终调用的是下面一个初始化方法 public ThreadPoolExecutor(int corePoolSize,
jdk-ThreadPoolExecutor(三)---内部Worker和执行方法
lwgzj的博客
06-26 980
第三篇了，其实关于多线程这边的话，我想一直分下去，每一篇都研究一点，不太想将所有的知识点都放在一起，放在一起，读起来太费力了，看起来也不舒服，分下来之后至少一目了然，一个个知识点很清晰。 今天的话就来看看它的一个内部类worker，这个worker应该算是核心了。 private final class Worker extends AbstractQueuedSynchron
jdk-HashMap
lwgzj的博客
03-27 532
HashMap是我有意识去研究jdk源码时看的第一个。印象很深刻，当我看过源码之后，突然发现自己对之前很多东西理解突然透彻了，有此感叹。 笔者有幸也参与过公司的几次面试(跟着打酱油而已)，有时候也有自己提问的时候，很多时候都是问关于HashMap的问题，并发现，其实很多面试者对这方面了解的并不好，基本80%都是在用，但是对于它的机制和处理过程确知之甚少。所以笔者也很纳闷，至少很大一部分人都没有关
JDK8跨平台安装包发布：Windows与Linux双版本
Java还提供了多种并发工具和框架来辅助多线程编程，例如java.util.concurrent包中的并发集合、Executor框架、CountDownLatch、CyclicBarrier、Semaphore等。这些工具和框架可以帮助开发者更简洁、高效地处理并发问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值