CyclicBarrier用法

最新推荐文章于 2024-08-28 14:45:05 发布
最新推荐文章于 2024-08-28 14:45:05 发布
阅读量183 收藏
点赞数
分类专栏： Java并发管理

字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier，当调用await()方法之后，线程就处于barrier了。

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

1   public CyclicBarrier(int parties, Runnable barrierAction) {
2   }
3    
4   public CyclicBarrier(int parties) {
5   }

参数parties指让多少个线程或者任务等待至barrier状态；参数barrierAction为当这些线程都达到barrier状态时会执行的内容。

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

1   public int await() throws InterruptedException, BrokenBarrierException { };
2   public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { };

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

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

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

1   public class Test {
2       public static void main(String[] args) {
3           int N = 4;
4           CyclicBarrier barrier  = new CyclicBarrier(N);
5           for(int i=0;i<N;i++)
6               new Writer(barrier).start();
7       }
8       static class Writer extends Thread{
9           private CyclicBarrier cyclicBarrier;
10          public Writer(CyclicBarrier cyclicBarrier) {
11              this.cyclicBarrier = cyclicBarrier;
12          }
13   
14          @Override
15          public void run() {
16              System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
17              try {
18                  Thread.sleep(5000);      //以睡眠来模拟写入数据操作
19                  System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
20                  cyclicBarrier.await();
21              } catch (InterruptedException e) {
22                  e.printStackTrace();
23              }catch(BrokenBarrierException e){
24                  e.printStackTrace();
25              }
26              System.out.println("所有线程写入完毕，继续处理其他任务...");
27          }
28      }
29  }

执行结果：

1   线程Thread-0正在写入数据...
2   线程Thread-3正在写入数据...
3   线程Thread-2正在写入数据...
4   线程Thread-1正在写入数据...
5   线程Thread-2写入数据完毕，等待其他线程写入完毕
6   线程Thread-0写入数据完毕，等待其他线程写入完毕
7   线程Thread-3写入数据完毕，等待其他线程写入完毕
8   线程Thread-1写入数据完毕，等待其他线程写入完毕
9   所有线程写入完毕，继续处理其他任务...
10  所有线程写入完毕，继续处理其他任务...
11  所有线程写入完毕，继续处理其他任务...
12  所有线程写入完毕，继续处理其他任务...

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

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

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

1   public class Test {
2       public static void main(String[] args) {
3           int N = 4;
4           CyclicBarrier barrier  = new CyclicBarrier(N,new Runnable() {
5               @Override
6               public void run() {
7                   System.out.println("当前线程"+Thread.currentThread().getName());   
8               }
9           });
10   
11          for(int i=0;i<N;i++)
12              new Writer(barrier).start();
13      }
14      static class Writer extends Thread{
15          private CyclicBarrier cyclicBarrier;
16          public Writer(CyclicBarrier cyclicBarrier) {
17              this.cyclicBarrier = cyclicBarrier;
18          }
19   
20          @Override
21          public void run() {
22              System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
23              try {
24                  Thread.sleep(5000);      //以睡眠来模拟写入数据操作
25                  System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
26                  cyclicBarrier.await();
27              } catch (InterruptedException e) {
28                  e.printStackTrace();
29              }catch(BrokenBarrierException e){
30                  e.printStackTrace();
31              }
32              System.out.println("所有线程写入完毕，继续处理其他任务...");
33          }
34      }
35  }

运行结果：

1   线程Thread-0正在写入数据...
2   线程Thread-1正在写入数据...
3   线程Thread-2正在写入数据...
4   线程Thread-3正在写入数据...
5   线程Thread-0写入数据完毕，等待其他线程写入完毕
6   线程Thread-1写入数据完毕，等待其他线程写入完毕
7   线程Thread-2写入数据完毕，等待其他线程写入完毕
8   线程Thread-3写入数据完毕，等待其他线程写入完毕
9   当前线程Thread-3
10  所有线程写入完毕，继续处理其他任务...
11  所有线程写入完毕，继续处理其他任务...
12  所有线程写入完毕，继续处理其他任务...
13  所有线程写入完毕，继续处理其他任务...

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

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

1   public class Test {
2       public static void main(String[] args) {
3           int N = 4;
4           CyclicBarrier barrier  = new CyclicBarrier(N);
5    
6           for(int i=0;i<N;i++) {
7               if(i<N-1)
8                   new Writer(barrier).start();
9               else {
10                  try {
11                      Thread.sleep(5000);
12                  } catch (InterruptedException e) {
13                      e.printStackTrace();
14                  }
15                  new Writer(barrier).start();
16              }
17          }
18      }
19      static class Writer extends Thread{
20          private CyclicBarrier cyclicBarrier;
21          public Writer(CyclicBarrier cyclicBarrier) {
22              this.cyclicBarrier = cyclicBarrier;
23          }
24   
25          @Override
26          public void run() {
27              System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
28              try {
29                  Thread.sleep(5000);      //以睡眠来模拟写入数据操作
30                  System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
31                  try {
32                      cyclicBarrier.await(2000, TimeUnit.MILLISECONDS);
33                  } catch (TimeoutException e) {
34                      // TODO Auto-generated catch block
35                      e.printStackTrace();
36                  }
37              } catch (InterruptedException e) {
38                  e.printStackTrace();
39              }catch(BrokenBarrierException e){
40                  e.printStackTrace();
41              }
42              System.out.println(Thread.currentThread().getName()+"所有线程写入完毕，继续处理其他任务...");
43          }
44      }
45  }

执行结果：

1   线程Thread-0正在写入数据...
2   线程Thread-2正在写入数据...
3   线程Thread-1正在写入数据...
4   线程Thread-2写入数据完毕，等待其他线程写入完毕
5   线程Thread-0写入数据完毕，等待其他线程写入完毕
6   线程Thread-1写入数据完毕，等待其他线程写入完毕
7   线程Thread-3正在写入数据...
8   java.util.concurrent.TimeoutException
9   Thread-1所有线程写入完毕，继续处理其他任务...
10  Thread-0所有线程写入完毕，继续处理其他任务...
11      at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
12      at java.util.concurrent.CyclicBarrier.await(Unknown Source)
13      at com.cxh.test1.Test$Writer.run(Test.java:58)
14  java.util.concurrent.BrokenBarrierException
15      at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
16      at java.util.concurrent.CyclicBarrier.await(Unknown Source)
17      at com.cxh.test1.Test$Writer.run(Test.java:58)
18  java.util.concurrent.BrokenBarrierException
19      at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
20      at java.util.concurrent.CyclicBarrier.await(Unknown Source)
21      at com.cxh.test1.Test$Writer.run(Test.java:58)
22  Thread-2所有线程写入完毕，继续处理其他任务...
23  java.util.concurrent.BrokenBarrierException
24  线程Thread-3写入数据完毕，等待其他线程写入完毕
25      at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
26      at java.util.concurrent.CyclicBarrier.await(Unknown Source)
27      at com.cxh.test1.Test$Writer.run(Test.java:58)
28  Thread-3所有线程写入完毕，继续处理其他任务...

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

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

1   public class Test {
2       public static void main(String[] args) {
3           int N = 4;
4           CyclicBarrier barrier  = new CyclicBarrier(N);
5    
6           for(int i=0;i<N;i++) {
7               new Writer(barrier).start();
8           }
9    
10          try {
11              Thread.sleep(25000);
12          } catch (InterruptedException e) {
13              e.printStackTrace();
14          }
15   
16          System.out.println("CyclicBarrier重用");
17   
18          for(int i=0;i<N;i++) {
19              new Writer(barrier).start();
20          }
21      }
22      static class Writer extends Thread{
23          private CyclicBarrier cyclicBarrier;
24          public Writer(CyclicBarrier cyclicBarrier) {
25              this.cyclicBarrier = cyclicBarrier;
26          }
27   
28          @Override
29          public void run() {
30              System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
31              try {
32                  Thread.sleep(5000);      //以睡眠来模拟写入数据操作
33                  System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
34   
35                  cyclicBarrier.await();
36              } catch (InterruptedException e) {
37                  e.printStackTrace();
38              }catch(BrokenBarrierException e){
39                  e.printStackTrace();
40              }
41              System.out.println(Thread.currentThread().getName()+"所有线程写入完毕，继续处理其他任务...");
42          }
43      }
44  }

执行结果：

1   线程Thread-0正在写入数据...
2   线程Thread-1正在写入数据...
3   线程Thread-3正在写入数据...
4   线程Thread-2正在写入数据...
5   线程Thread-1写入数据完毕，等待其他线程写入完毕
6   线程Thread-3写入数据完毕，等待其他线程写入完毕
7   线程Thread-2写入数据完毕，等待其他线程写入完毕
8   线程Thread-0写入数据完毕，等待其他线程写入完毕
9   Thread-0所有线程写入完毕，继续处理其他任务...
10  Thread-3所有线程写入完毕，继续处理其他任务...
11  Thread-1所有线程写入完毕，继续处理其他任务...
12  Thread-2所有线程写入完毕，继续处理其他任务...
13  CyclicBarrier重用
14  线程Thread-4正在写入数据...
15  线程Thread-5正在写入数据...
16  线程Thread-6正在写入数据...
17  线程Thread-7正在写入数据...
18  线程Thread-7写入数据完毕，等待其他线程写入完毕
19  线程Thread-5写入数据完毕，等待其他线程写入完毕
20  线程Thread-6写入数据完毕，等待其他线程写入完毕
21  线程Thread-4写入数据完毕，等待其他线程写入完毕
22  Thread-4所有线程写入完毕，继续处理其他任务...
23  Thread-5所有线程写入完毕，继续处理其他任务...
24  Thread-6所有线程写入完毕，继续处理其他任务...
25  Thread-7所有线程写入完毕，继续处理其他任务...

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

Hengyu-coder
关注
专栏目录
并发编程系列之CyclicBarrier用法简介
Nicky's blog
11-29 1494
CyclicBarrier，协同指定数目的线程，让这些线程都在这个屏障前等待，直到所有的线程都到这个屏障前，再一起继续执行。线程执行完成后，这个屏障可以再次使用，因此被称之为循环屏障。
如何使用CyclicBarrier？
陈九礼
08-13 822
CyclicBarrier 是一种线程协作的方法，它可以让一个线程执行到某个点停止，并等待其它线程到达这个点集结完毕再继续运行。 从名字的翻译可以看出 CyclicBarrier是「篱栅」，你可以想象在某个赛道上有比赛，每场比赛需要5匹马到达篱栅才能开始，如下 从这图可以看出，有5匹马要进行比赛，但由于马5没有到达赛场，而导致比赛不能开始，下面是代码演示 public class CyclicBarrierDemo { static CyclicBarrier cyclicBarrier = n
CyclicBarrier的用法
08-14
NULL 博文链接：https://hubowei1.iteye.com/blog/2312471
java中CyclicBarrier的简单用法
sh_c1991的专栏
05-29 637
CyclicBarrier 和 CountDownLatch 都可以用来让一组线程等待其它线程。与 CyclicBarrier 不同的是，CountdownLatch 不能重新使用。 1 public class TestCyclicBarrier { 2 3 private static final int THREAD_NUM = 5; 4 5 p
JUC小册——CyclicBarrier的用法
最新发布
程序员阿皓的博客
08-28 944
CyclicBarrier 是 Java 并发包中的一个同步工具类，位于 java.util.concurrent 包中。允许一组线程相互等待，直到所有线程都到达某个公共的屏障点（barrier）。一旦所有线程都到达屏障， CyclicBarrier 会释放所有等待的线程，使它们继续执行。CyclicBarrier 主要用于协调多个线程的执行。它的构造函数需要一个整数参数，表示参与屏障的线程数量。await()：使当前线程等待，直到所有参与线程都调用了此方法。：返回当前在等待屏障的线程数量。
CyclicBarrier用法.docx
06-11
1. **重复使用性**：与CountDownLatch不同，CyclicBarrier可以在所有线程都达到屏障点后重置，允许再次使用。这意味着一旦所有线程都完成各自的任务并调用await()方法，屏障将被重置，计数器恢复到初始值，可以进行...
CyclicBarrier 用法
05-23
CyclicBarrier 的用法如下： 1. 创建一个 CyclicBarrier 对象，并指定需要等待的线程数量和屏障点执行的操作： ``` CyclicBarrier barrier = new CyclicBarrier(3, () -> { // 屏障点执行的操作 System.out....
CyclicBarrier 用法详解
.
03-27 8566
CyclicBarrier 用法详解 CyclicBarrier使用场景 用于协调多个线程同步执行操作的场合，所有线程等待完成,然后一起做事情( 相互之间都准备好,然后一起做事情 ) 例如百米赛跑，必须等待所有运动员都准备好了，才能比赛。 运动员准备好，裁判也准备好，才能开始正式比赛。 CyclicBarrier cyclicBarrier = new CyclicBarrier(3); new Thread(() -> { try {
CyclicBarrier
weixin_34203426的博客
12-18 125
1CyclicBarrier CyclicBarrier是让一组线程达到一个屏障（也叫做同步点），当这一组线程执行到达这个屏障（cyclicBarrier.await()代码处）时，这组线程才会继续往下执行。 CyclicBarrier比较适用于多线程计算的场景，当这些线程都执行到某一个预设地点以后，再执行另外的操作。例如，开多个线程批量处理数据，多所...
CyclicBarrier 的用法
shuang1562的专栏
12-13 1709
/** * 实现功能是将goodsReqDtoList作为calcEstimateAmount方法的入参，然后将最终的结果放入map中进行返回 * 1.根据 goodsReqDtoList 的长度，判断我们要开多少个线程 * 2.将每个线程获得的结果放入 map 中，等到所有线程都计算完，将结果进行返回 * 3.当所有子线程都执行完毕后，要求每个线程再打印出 “AAA” 字符串 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值