java.util.concurrent系列之--CyclicBarrier

最新推荐文章于 2024-05-06 18:26:10 发布
最新推荐文章于 2024-05-06 18:26:10 发布
阅读量81 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/u/3136594/blog/1593227
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

一、CyclicBarrier用法

cyclic ['saɪklɪk; 'sɪk-] 环的；循环的；周期的

Barrier ['bærɪə] n. 障碍物，屏障；界线、 vt. 把…关入栅栏 、n. (Barrier)人名；(法)巴里耶

字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所

有等待线程都被释放以后，CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier，当调用await()方

法之后，线程就处于barrier了。

CyclicBarrier类位于java.util.concurrent包下，CyclicBarrier提供2个构造器：

public CyclicBarrier(int parties, Runnable barrierAction) {
}
 
public CyclicBarrier(int parties) {
}

参数parties指让多少个线程或者任务等待至barrier状态；参数barrierAction为当这些线程都达到barrier状

态时会执行的内容。

然后CyclicBarrier中最重要的方法就是await方法，它有2个重载版本：

public int await() throws InterruptedException, BrokenBarrierException { };

public int await(long timeout, TimeUnit unit)throws 

InterruptedException,BrokenBarrierException,TimeoutException { };

第一个版本比较常用，用来挂起当前线程，直至所有线程都到达barrier状态再同时执行后续任务；

第二个版本是让这些线程等待至一定的时间，如果还有线程没有到达barrier状态就直接让到达barrier的线程执行后续任务。

二、例子1：

假若有若干个线程都要进行写数据操作，并且只有所有线程都完成写数据操作之后，这些线程才能继续做后面的事情，此时就可以利用CyclicBarrier了：

public class Test {
    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier barrier  = new CyclicBarrier(N);
        for(int i=0;i<N;i++)
            new Writer(barrier).start();
    }
    static class Writer extends Thread{
        private CyclicBarrier cyclicBarrier;
        public Writer(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }
 
        @Override
        public void run() {
            System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
            try {
                Thread.sleep(5000);      //以睡眠来模拟写入数据操作
                System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println("所有线程写入完毕，继续处理其他任务...");
        }
    }
}

执行结果：

输入图片说明

从上面输出结果可以看出，每个写入线程执行完写数据操作之后，就在等待其他线程写入操作完毕。

当所有线程线程写入操作完毕之后，所有线程就继续进行后续的操作了。

三、例子2：

如果说想在所有线程写入操作完之后，进行额外的其他操作可以为CyclicBarrier提供Runnable参数：

public class Test {
    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier barrier  = new CyclicBarrier(N,new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程"+Thread.currentThread().getName());   
            }
        });
 
        for(int i=0;i<N;i++)
            new Writer(barrier).start();
    }
    static class Writer extends Thread{
        private CyclicBarrier cyclicBarrier;
        public Writer(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }
 
        @Override
        public void run() {
            System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
            try {
                Thread.sleep(5000);      //以睡眠来模拟写入数据操作
                System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println("所有线程写入完毕，继续处理其他任务...");
        }
    }
}

运行结果：

输入图片说明

从结果可以看出，当四个线程都到达barrier状态后，会从四个线程中选择一个线程去执行Runnable。

四、例子3：

下面看一下为await指定时间的效果：

public class Test {
    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier barrier  = new CyclicBarrier(N);
 
        for(int i=0;i<N;i++) {
            if(i<N-1)
                new Writer(barrier).start();
            else {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                new Writer(barrier).start();
            }
        }
    }
    static class Writer extends Thread{
        private CyclicBarrier cyclicBarrier;
        public Writer(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }
 
        @Override
        public void run() {
            System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
            try {
                Thread.sleep(5000);      //以睡眠来模拟写入数据操作
                System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
                try {
                    cyclicBarrier.await(2000, TimeUnit.MILLISECONDS);
                } catch (TimeoutException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"所有线程写入完毕，继续处理其他任务...");
        }
    }
}

执行结果：

输入图片说明

上面的代码在main方法的for循环中，故意让最后一个线程启动延迟，因为在前面三个线程都达到barrier之后，等待了指定的时间发现第四个线程还没有达到barrier，就抛出异常并继续执行后面的任务。

五、例子4：

另外CyclicBarrier是可以重用的，看下面这个例子：

public class Test {
    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier barrier  = new CyclicBarrier(N);
 
        for(int i=0;i<N;i++) {
            new Writer(barrier).start();
        }
 
        try {
            Thread.sleep(25000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        System.out.println("CyclicBarrier重用");
 
        for(int i=0;i<N;i++) {
            new Writer(barrier).start();
        }
    }
    static class Writer extends Thread{
        private CyclicBarrier cyclicBarrier;
        public Writer(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }
 
        @Override
        public void run() {
            System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
            try {
                Thread.sleep(5000);      //以睡眠来模拟写入数据操作
                System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
 
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"所有线程写入完毕，继续处理其他任务...");
        }
    }
}

执行结果：

输入图片说明

从执行结果可以看出，在初次的4个线程越过barrier状态后，又可以用来进行新一轮的使用。而CountDownLatch无法进行重复使用。

转载于:https://my.oschina.net/u/3136594/blog/1593227

weixin_33933118
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java并发工具包 java.util.concurrent中文版用户指南pdf
01-30
1. java.util.concurrent - Java 并发工具包 2. 阻塞队列 BlockingQueue 3. 数组阻塞队列 ArrayBlockingQueue 4. 延迟队列 DelayQueue 5. 链阻塞队列 LinkedBlockingQueue 6. 具有优先级的阻塞队列 ...
java.util.concurrent.CyclicBarrier同步屏障工具类源码解析
sunpy
10-09 340
1.CyclicBarrier工具类的特点 CyclicBarrier采用一种屏障的方式来控制线程，让所有线程停在某一点，已到的等最后到才完事。先到的线程将处于阻塞的状态。 2.初识CyclicBarrier http://blog.csdn.net/ya_1249463314/article/details/52822580 3.CyclicBarrier所属包 packa
java.util.concurrent.CyclicBarrier
qq_44734036的博客
08-19 182
CyclicBarrier 可循环屏障，作用是使得一组线程相互等待，直到最后一个线程到达屏障后，释放所有阻塞在该屏障上的线程，用于线程同步通信。 public class CyclicBarrier { private static class Generation { Generation() {} // 保护构造器 boolean broken; // 确认屏障是否被打破 } // 锁
java.util.concurrent.CyclicBarrier原理分析
APlus
09-13 431
一、引言 CyclicBarrier是Java并发工具包中的一个同步工具类，它允许一组线程互相等待，直到等待的线程达到指定数量后，所有等待的线程才会继续执行。我们可以称它为栅栏。 CyclicBarrier的构造方法有： 构造方法 解释 public CyclicBarrier(int parties) parties为等待线程的数量，等待的线程达到这个数后才会继...
java.util.concurrent并发包之CyclicBarrier
captian_900331的博客
02-23 204
一、CyclicBarrier类 CyclicBarrier类可以实现一组线程相互等待，当所有的线程达到某个屏障点以后再做后续的操作； CyclicBarrier类是可重复的栅栏； 二、CyclicBarrier类和CountDownLatch类的区别 CyclicBarrier强调的是N个线程相互等待，只要一个线程的任务没有完成，所有的线程均在等待状态； CountDownLatch类则是一个线程等待多个线程完成某件事情； CyclicBarrier类则是多个线程相互等待，大家都完成以后再继续后面的事情；
尚硅谷——java.util.concurrent和工具类
01-31
一、java.util.concurrent体系的主要大板块包含内容 二、Executors 三、Semaphor信号量 四、Exchanger线程交互 五、CyclicBarrier关卡模式 六、CountDownLatch计数器
Java并发工具包java.util.concurrent用户指南中英文对照阅读版.pdf
06-03
java.util.concurrent - Java 并发工具包 2. 阻塞队列 BlockingQueue 3. 数组阻塞队列 ArrayBlockingQueue 4. 延迟队列 DelayQueue 5. 链阻塞队列 LinkedBlockingQueue 6. 具有优先级的阻塞队列 ...
Java并发工具包java.util.concurrent用户指南中英文对照阅读版
12-14
本资源包含两个 pdf 文档，一本根据 Jakob Jenkov 最新博客 (http://tutorials.jenkov.com/java-util-concurrent/index.html) 整理的 java_util_concurrent_user_guide_en.pdf，一个中文翻译的 java_util_concurrent...
Java并发编程基础.pdf
04-19
Java并发编程基础主要包括以下几个核心方面： ...并发工具类：掌握Java并发包java.util.concurrent中提供的各种工具类，如CountDownLatch、CyclicBarrier、Semaphore等，它们简化了并发编程的复杂性。
cyclicBarrier
a1211529911的专栏
05-26 867
import java.io.IOException; import java.util.Random; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; import java.util.concurrent.ExecutorService; import
初识java.util.concurrent.CyclicBarrier
Alleney的博客
06-01 262
package learn; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors
Java多线程工具包java.util.concurrent---CyclicBarrier
upxiaofeng的专栏
11-21 409
什么是CyclicBarrier栅栏java.util.concurrent.CyclicBarrier 类是一种同步机制，它能够对处理一些算法的线程实现同步。换句话讲，它就是一个所有线程必须等待的一个栅栏，直到所有线程都到达这里，然后所有线程才可以继续做其他事情。图示如下： 有什么特点1、CyclicBarrier初始化时规定一个数目，然后计算调用了CyclicBarrier.await()进入
java concurrent 包下的CyclicBarrier方法
小十木的博客
06-11 231
CyclicBarrier用法 1、字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier，当调用await()方法之后，线程就处于barrier了。 2、通俗的讲 就是 使用 CyclicBrarrier 几个线程在执行到需要进行栅栏的地方时 调用 Cyc...
Java并发编程-同步辅助类之CyclicBarrier
记忆力不好的博客
06-06 2120
在上一篇文章中我们介绍了同步辅助类CountDownLatch，在Java Concurrent包下还有另一个同步辅助类CyclicBarrier与CountDownLatch非常类似，它也允许多个线程在莫个点进行同步，但CyclicBarrier类更加强大。 操作方法 提供两种构造函数带Runnable的 CyclicBarrier(int parties, Runnable barrierAc
链表刷题集
yajunjiao的专栏
04-30 816
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
Linux下网络编程-简易Epll服务器和客户端
最新发布
weixin_45256307的博客
05-06 108
Linux下网络编程-简易Epll服务器和客户端
《设计一款蓝牙热敏打印机》
唐顺才的博客
05-06 68
安卓apk用java + kotlin编写、上位机用Qt编写。主控芯片用易兆威蓝牙ic，通讯接口：蓝牙、串口、usb。
一篇文章，系统性聊聊Java注解
架构风清扬
05-06 479
一篇文章，系统性聊聊Java注解
介绍一下 java.util.concurrent.CyclicBarrier
05-29
`java.util.concurrent.CyclicBarrier`是一个多线程同步工具类，它可以让一组线程在达到某个屏障时相互等待，然后一起继续执行。它的作用类似于一个栅栏，所有线程必须到达栅栏前等待，当所有线程都到达后，栅栏才会...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值