java concurrent 包下的CyclicBarrier方法

最新推荐文章于 2021-08-19 17:50:01 发布
最新推荐文章于 2021-08-19 17:50:01 发布
阅读量246 收藏
点赞数
分类专栏： java基础 文章标签： CyclicBarrier java cocurrent
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37664223/article/details/91451975
版权

CyclicBarrier用法

  • 1、字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier，当调用await()方法之后，线程就处于barrier了。
  • 2、通俗的讲 就是 使用 CyclicBrarrier 几个线程在执行到需要进行栅栏的地方时 调用 CyclicBrarrier 对象的 wait 方法 然后当所有的对象都执行到栅栏的地方后 统一进行放行 往后执行；
  • 3、CyclicBarrier类位于java.util.concurrent包下，CyclicBarrier提供2个构造器：
    • public CyclicBarrier(int parties, Runnable barrierAction) {}
      • 参数barrierAction为当这些线程都达到barrier状态时会执行的内容；其实就是 当所有线程到达栅栏后，如果需要执行在放行前需要执行一个其他操作，可以实现runnable的run方法，此时会调用一个线程执行run方法；
    • public CyclicBarrier(int parties) {}
      • 参数parties指让多少个线程或者任务等待至barrier状态；
  • 4、然后CyclicBarrier中最重要的方法就是await方法，它有2个重载版本：
    • public int await() throws InterruptedException, BrokenBarrierException { };
      • 第一个版本比较常用，用来挂起当前线程，直至所有线程都到达barrier状态再同时执行后续任务；
    • public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { };
      • 第二个版本是让这些线程等待至一定的时间，如果还有线程没有到达barrier状态就直接让到达barrier的线程执行后续任务。
  • 5、代码案例：
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("所有线程写入完毕，继续处理其他任务...");
        }
    }
}


//        控制台输出
//        线程Thread-0正在写入数据...
//        线程Thread-3正在写入数据...
//        线程Thread-2正在写入数据...
//        线程Thread-1正在写入数据...
//        线程Thread-2写入数据完毕，等待其他线程写入完毕
//        线程Thread-0写入数据完毕，等待其他线程写入完毕
//        线程Thread-3写入数据完毕，等待其他线程写入完毕
//        线程Thread-1写入数据完毕，等待其他线程写入完毕
//        所有线程写入完毕，继续处理其他任务...
//        所有线程写入完毕，继续处理其他任务...
//        所有线程写入完毕，继续处理其他任务...
//        所有线程写入完毕，继续处理其他任务...
  • 6、代码案例：在所有线程写入操作完之后，进行额外的其他操作可以为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("所有线程写入完毕，继续处理其他任务...");
        }
    }
}
//        控制台输出
//        线程Thread-0正在写入数据...
//        线程Thread-1正在写入数据...
//        线程Thread-2正在写入数据...
//        线程Thread-3正在写入数据...
//        线程Thread-0写入数据完毕，等待其他线程写入完毕
//        线程Thread-1写入数据完毕，等待其他线程写入完毕
//        线程Thread-2写入数据完毕，等待其他线程写入完毕
//        线程Thread-3写入数据完毕，等待其他线程写入完毕
//        当前线程Thread-3
//        所有线程写入完毕，继续处理其他任务...
//        所有线程写入完毕，继续处理其他任务...
//        所有线程写入完毕，继续处理其他任务...
//        所有线程写入完毕，继续处理其他任务...
  • 7、代码案例：当栅栏处的wait方法使用带有设定时间参数的时候，当等待Barrier过程中 超过时间后 就抛出异常并继续执行后面的任务。
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 {                                //最后一个线程等待5000毫秒后再执行，使得其他线程会发生超时 抛出异常
                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()+"所有线程写入完毕，继续处理其他任务...");
        }
    }
}
//        控制台输出
//        线程Thread-0正在写入数据...
//        线程Thread-2正在写入数据...
//        线程Thread-1正在写入数据...
//        线程Thread-2写入数据完毕，等待其他线程写入完毕
//        线程Thread-0写入数据完毕，等待其他线程写入完毕
//        线程Thread-1写入数据完毕，等待其他线程写入完毕
//        线程Thread-3正在写入数据...
//        java.util.concurrent.TimeoutException
//        Thread-1所有线程写入完毕，继续处理其他任务...
//        Thread-0所有线程写入完毕，继续处理其他任务...
//        at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
//        at java.util.concurrent.CyclicBarrier.await(Unknown Source)
//        at com.cxh.test1.Test$Writer.run(Test.java:58)
//        java.util.concurrent.BrokenBarrierException
//        at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
//        at java.util.concurrent.CyclicBarrier.await(Unknown Source)
//        at com.cxh.test1.Test$Writer.run(Test.java:58)
//        java.util.concurrent.BrokenBarrierException
//        at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
//        at java.util.concurrent.CyclicBarrier.await(Unknown Source)
//        at com.cxh.test1.Test$Writer.run(Test.java:58)
//        Thread-2所有线程写入完毕，继续处理其他任务...
//        java.util.concurrent.BrokenBarrierException
//        线程Thread-3写入数据完毕，等待其他线程写入完毕
//        at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
//        at java.util.concurrent.CyclicBarrier.await(Unknown Source)
//        at com.cxh.test1.Test$Writer.run(Test.java:58)
//        Thread-3所有线程写入完毕，继续处理其他任务...
  • 8、代码案例：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()+"所有线程写入完毕，继续处理其他任务...");
        }
    }
}


//        控制台输出
//        线程Thread-0正在写入数据...
//        线程Thread-1正在写入数据...
//        线程Thread-3正在写入数据...
//        线程Thread-2正在写入数据...
//        线程Thread-1写入数据完毕，等待其他线程写入完毕
//        线程Thread-3写入数据完毕，等待其他线程写入完毕
//        线程Thread-2写入数据完毕，等待其他线程写入完毕
//        线程Thread-0写入数据完毕，等待其他线程写入完毕
//        Thread-0所有线程写入完毕，继续处理其他任务...
//        Thread-3所有线程写入完毕，继续处理其他任务...
//        Thread-1所有线程写入完毕，继续处理其他任务...
//        Thread-2所有线程写入完毕，继续处理其他任务...
//        CyclicBarrier重用
//        线程Thread-4正在写入数据...
//        线程Thread-5正在写入数据...
//        线程Thread-6正在写入数据...
//        线程Thread-7正在写入数据...
//        线程Thread-7写入数据完毕，等待其他线程写入完毕
//        线程Thread-5写入数据完毕，等待其他线程写入完毕
//        线程Thread-6写入数据完毕，等待其他线程写入完毕
//        线程Thread-4写入数据完毕，等待其他线程写入完毕
//        Thread-4所有线程写入完毕，继续处理其他任务...
//        Thread-5所有线程写入完毕，继续处理其他任务...
//        Thread-6所有线程写入完毕，继续处理其他任务...
//        Thread-7所有线程写入完毕，继续处理其他任务...
小十木
关注
专栏目录
java concurrent 包　详细解析
03-14
Java并发包（java.concurrent）是Java平台中处理多线程编程的核心工具包，它提供了丰富的类和接口，使得开发者能够高效、安全地编写多线程程序。这个包的设计目标是提高并发性能，减少同步代码的复杂性，并提供高级...
Java的concurrent包动画演示
07-30
Java的`concurrent`包是Java多线程编程的核心组件，它包含了一系列高效、线程安全的类和接口，使得开发者能够更容易地处理并发问题。这个包中的工具和类是Java平台对并行编程的强大支持，它极大地提升了程序在多...
java.util.concurrent.CyclicBarrier
qq_44734036的博客
08-19 200
CyclicBarrier 可循环屏障，作用是使得一组线程相互等待，直到最后一个线程到达屏障后，释放所有阻塞在该屏障上的线程，用于线程同步通信。 public class CyclicBarrier { private static class Generation { Generation() {} // 保护构造器 boolean broken; // 确认屏障是否被打破 } // 锁
Java多线程工具包java.util.concurrent---CyclicBarrier
upxiaofeng的专栏
11-21 441
什么是CyclicBarrier栅栏java.util.concurrent.CyclicBarrier 类是一种同步机制，它能够对处理一些算法的线程实现同步。换句话讲，它就是一个所有线程必须等待的一个栅栏，直到所有线程都到达这里，然后所有线程才可以继续做其他事情。图示如下： 有什么特点1、CyclicBarrier初始化时规定一个数目，然后计算调用了CyclicBarrier.await()进入
java.util.concurrent.CyclicBarrier原理分析
APlus
09-13 445
一、引言 CyclicBarrier是Java并发工具包中的一个同步工具类，它允许一组线程互相等待，直到等待的线程达到指定数量后，所有等待的线程才会继续执行。我们可以称它为栅栏。 CyclicBarrier的构造方法有： 构造方法 解释 public CyclicBarrier(int parties) parties为等待线程的数量，等待的线程达到这个数后才会继...
Concurrent - CyclicBarrier
jvisualvm
12-09 145
原创转载请注明出处：http://agilestyle.iteye.com/blog/2343979   CyclicBarrier CyclicBarrier允许一组线程互相等待，直到到达某个公共屏障点（common barrier point），这些线程必须实时地互相等待，这种情况下就可以使用CyclicBarrier来方便地实现这样的功能。另外，CyclicBarrier的公共屏障...
cyclicBarrier
a1211529911的专栏
05-26 883
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并发工具包 java.util.concurrent中文版-带书签版
08-05
通过这份中文版的`java.util.concurrent`用户指南，读者可以深入理解这些并发工具的使用方法和原理，提升在多线程环境下的编程能力。书签功能使得学习更加便捷，能够快速定位到感兴趣的章节或知识点，对Java并发编程...
谈谈java的concurrent用法
09-03
在Java编程中，`java.util.concurrent`（简称`concurrent`）包是处理多线程并发问题的核心工具。这个包的引入极大地简化了并发编程，特别是从JDK1.5版本开始，由Doug Lea设计的一系列并发工具类使得编写高效、安全的...
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
weixin_33933118的博客
12-21 91
2019独角兽企业重金招聘Python工程师标准>>> ...
java.util.concurrent并发包之CyclicBarrier
captian_900331的博客
02-23 257
一、CyclicBarrier类 CyclicBarrier类可以实现一组线程相互等待，当所有的线程达到某个屏障点以后再做后续的操作； CyclicBarrier类是可重复的栅栏； 二、CyclicBarrier类和CountDownLatch类的区别 CyclicBarrier强调的是N个线程相互等待，只要一个线程的任务没有完成，所有的线程均在等待状态； CountDownLatch类则是一个线程等待多个线程完成某件事情； CyclicBarrier类则是多个线程相互等待，大家都完成以后再继续后面的事情；
初识java.util.concurrent.CyclicBarrier
Alleney的博客
06-01 275
package learn; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors
concurrent包下的CycicBarrier用法
不断总结不断成长
12-30 652
import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /**  * Cycli
java.util.concurrent.CyclicBarrier同步屏障工具类源码解析
sunpy
10-09 366
1.CyclicBarrier工具类的特点 CyclicBarrier采用一种屏障的方式来控制线程，让所有线程停在某一点，已到的等最后到才完事。先到的线程将处于阻塞的状态。 2.初识CyclicBarrier http://blog.csdn.net/ya_1249463314/article/details/52822580 3.CyclicBarrier所属包 packa
Java并发编程-同步辅助类之CyclicBarrier
记忆力不好的博客
06-06 2163
在上一篇文章中我们介绍了同步辅助类CountDownLatch，在Java Concurrent包下还有另一个同步辅助类CyclicBarrier与CountDownLatch非常类似，它也允许多个线程在莫个点进行同步，但CyclicBarrier类更加强大。 操作方法 提供两种构造函数带Runnable的 CyclicBarrier(int parties, Runnable barrierAc
【java.util.concurrent】CyclicBarrier解析
weixin_34417814的博客
08-09 84
为什么80%的码农都做不了架构师？>>> ...
java.util.concurrent中的几种同步工具类（CyclicBarrier，CountDownLatch，Semaphore）
qq_40297844的博客
09-29 336
1.CyclicBarrier（栅栏） 1.1.简介 栅栏类似于闭锁，它能阻塞一组线程直到某个事件的发生。栅栏与闭锁的关键区别在于，所有的线程必须同时到达栅栏位置，才能继续执行。闭锁用于等待事件，而栅栏用于等待其他线程。 CyclicBarrier可以使一定数量的线程反复地在栅栏位置处汇集。当线程到达栅栏位置时将调用await方法，这个方法将阻塞直到所有线程都到达栅栏位置。如果所有线程都到达栅栏位置，那么栅栏将打开，此时所有的线程都将被释放，而栅栏将被重置以便下次使用。 1.2.用生活中的例子通过代码来演示
介绍一下 java.util.concurrent.CyclicBarrier
最新发布
05-29
`java.util.concurrent.CyclicBarrier`是一个多线程同步工具类，它可以让一组线程在达到某个屏障时相互等待，然后一起继续执行。它的作用类似于一个栅栏，所有线程必须到达栅栏前等待，当所有线程都到达后，栅栏才会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值