《Java源码分析》:CyclicBarrier(part one)
来源:互联网 发布:宋真宗哪年驾崩 知乎 编辑:程序博客网 时间:2024/05/16 18:30
《Java源码分析》:CyclicBarrier (part one)
CyclicBarrier字面意思回环栅栏,通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后,CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier,当调用await()方法之后,线程就处于barrier了。
举个例子哈:当我们10个人相约包车去成都玩,车早上就在学校门口等着我们10个人上车(规定只有10个人全部上车后才能开车出发),现在陆陆续续的一个一个同学上车了,在第10个人到来之前,其它人都必须等待。在第10个人到来之后车就出发去成都了每个人就开始该干嘛就干嘛去了。
以上就是CyclicBarrier.
当然了,上面说的是正常不出意外的情况。CyclicBarrier和等车的例子一样,会出现各种情况(意外):
例如:在车上等待的同学,突然有事(例如:老板打电话有事)不去玩了,则就会告诉所有人,我不去了哈,于是大家就都不需要等待了,各自下车去忙自己的事去。
还有一些情况,这里就不用例子一一来说明情况了。
CyclicBarrier常见的方法
有两个构造函数
CyclicBarrier(int parties)
创建一个新的 CyclicBarrier,它将在给定数量的参与者(线程)处于等待状态时启动,但它不会在启动 barrier 时执行预定义的操作。
CyclicBarrier(int parties, Runnable barrierAction)
创建一个新的 CyclicBarrier,它将在给定数量的参与者(线程)处于等待状态时启动,并在启动 barrier 时执行给定的屏障操作,该操作由最后一个进入 barrier 的线程执行。
int await()
在所有参与者都已经在此 barrier 上调用 await 方法之前,将一直等待。 所有线程都到达barrier状态再同时执行后续任务;
int await(long timeout, TimeUnit unit)
在所有参与者都已经在此屏障上调用 await 方法之前将一直等待,或者超出了指定的等待时间。
下面先看几个关于CyclicBarrier的应用,然后再来从源码的角度来分析。
例子1
假设有3个线程,3个线程各自进行初始化,但是只有3个线程都初始化完成之后才使得3个线程同时继续运行干其它的工作。
先看利用CyclicBarrier(int parties) 构造对象并调用await() 进行等待的简单应用。
public class CyclicBarrierDemo { private final static int NUM = 3; public static void main(String[] args) { final CyclicBarrier barrier = new CyclicBarrier(NUM); for(int i=0;i<NUM;i++){ new Task(barrier).start(); } } static class Task extends Thread{ private CyclicBarrier barrier; public Task(CyclicBarrier barrier){ this.barrier = barrier; } @Override public void run() { System.out.println(Thread.currentThread().getName() + " 初始化开始。。。"); try { Thread.sleep(2000);//模拟初始化 System.out.println(Thread.currentThread().getName() + " 初始化结束,等待其他task初始化结束,然后再继续运行!"); barrier.await();//在所有线程均到达此barrier前,等待 } catch (InterruptedException e) { e.printStackTrace(); } catch (BrokenBarrierException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " 其他task初始化结束,开始运行!"); } } }
运行结果如下:
Thread-0 初始化开始。。。Thread-1 初始化开始。。。Thread-2 初始化开始。。。Thread-0 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-2 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-1 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-2 其他task初始化结束,开始运行!Thread-1 其他task初始化结束,开始运行!Thread-0 其他task初始化结束,开始运行!
看了这个例子,CyclicBarrier是不是比较容易理解和应用。
例子2
在API文档中我们知道CyclicBarrier是可以重新利用的,通过下面这个例子就清楚了。
public class CyclicBarrierDemo2 { private final static int NUM = 3; public static void main(String[] args) { final CyclicBarrier barrier = new CyclicBarrier(NUM); for(int i=0;i<NUM;i++){ new Task(barrier).start(); } try { Thread.sleep(20000);//等待其他线程执行完毕,当然我们这里可以选择使用CountDownLatch来实现。 System.out.println("main线程休息结束!"); } catch (InterruptedException e) { e.printStackTrace(); } //观察下CyclicBarrier是否可以复用 for(int i=0;i<NUM;i++){ new Task(barrier).start(); } } static class Task extends Thread{ private CyclicBarrier barrier; public Task(CyclicBarrier barrier){ this.barrier = barrier; } @Override public void run() { System.out.println(Thread.currentThread().getName() + " 初始化开始。。。"); try { Thread.sleep(2000); System.out.println(Thread.currentThread().getName() + " 初始化结束,等待其他task初始化结束,然后再继续运行!"); barrier.await(); } catch (InterruptedException e) { e.printStackTrace(); } catch (BrokenBarrierException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " 其他task初始化结束,开始运行!"); } } }
运行结果如下:
Thread-1 初始化开始。。。Thread-0 初始化开始。。。Thread-2 初始化开始。。。Thread-1 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-0 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-2 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-2 其他task初始化结束,开始运行!Thread-1 其他task初始化结束,开始运行!Thread-0 其他task初始化结束,开始运行!main线程休息结束!Thread-3 初始化开始。。。Thread-4 初始化开始。。。Thread-5 初始化开始。。。Thread-4 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-3 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-5 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-5 其他task初始化结束,开始运行!Thread-4 其他task初始化结束,开始运行!Thread-3 其他task初始化结束,开始运行!
结论:从结果可以看出,CyclicBarrier确实是可以重用的。而CountDownLatch是不可以重用的
例子3
这个例子来看下 int await(long timeout, TimeUnit unit) 的应用。
让这些线程等待至一定的时间,如果还有线程没有到达barrier状态直接抛异常让到达barrier的线程执行后续任务。
public class CyclicBarrierDemo3 { private final static int NUM = 3; public static void main(String[] args){ final CyclicBarrier barrier = new CyclicBarrier(NUM); for(int i=0;i<NUM;i++){ if(i==NUM-1){ try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } //先休息再开启线程 new Task(barrier).start(); } else{ new Task(barrier).start(); } } } static class Task extends Thread{ private CyclicBarrier barrier; public Task(CyclicBarrier barrier){ this.barrier = barrier; } @Override public void run() { System.out.println(Thread.currentThread().getName() + " 初始化开始。。。"); try { Thread.sleep(2000);//模拟初始化 System.out.println(Thread.currentThread().getName() + " 初始化结束,等待其他task初始化结束,然后再继续运行!"); barrier.await(3, TimeUnit.SECONDS);//等待3秒,如果所有线程3秒后还没有到达barrier,则会抛异常然后继续往下面运行 } catch (InterruptedException e) { e.printStackTrace(); } catch (BrokenBarrierException e) { e.printStackTrace(); } catch (TimeoutException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " 其他task初始化结束,开始运行!"); } } }
运行结果如下:
Thread-1 初始化开始。。。Thread-0 初始化开始。。。Thread-1 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-0 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-2 初始化开始。。。java.util.concurrent.TimeoutException at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:257) at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:435) at com.wrh.readwritelock.CyclicBarrierDemo3$Task.run(CyclicBarrierDemo3.java:45)Thread-0 其他task初始化结束,开始运行!java.util.concurrent.BrokenBarrierException at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250) at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:435) at com.wrh.readwritelock.CyclicBarrierDemo3$Task.run(CyclicBarrierDemo3.java:45)Thread-1 其他task初始化结束,开始运行!Thread-2 初始化结束,等待其他task初始化结束,然后再继续运行!java.util.concurrent.BrokenBarrierException at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207) at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:435) at com.wrh.readwritelock.CyclicBarrierDemo3$Task.run(CyclicBarrierDemo3.java:45)Thread-2 其他task初始化结束,开始运行!
结论:从结果可以看出,如果使用await(time,unit);当到达时间后,还存在其他线程没有到达等待点,则已经到达等待点的线程就会直接抛异常继续往下面运行
例子4
下面当创建CyclicBarrier对象时,指定一个Runnable对象。即利用CyclicBarrier(int parties, Runnable barrierAction) 构造函数来构造一个对象。
CyclicBarrier(int parties, Runnable barrierAction)
创建一个新的 CyclicBarrier,它将在给定数量的参与者(线程)处于等待状态时启动,并在启动 barrier 时执行给定的屏障操作,该操作由最后一个进入 barrier 的线程执行。
public class CyclicBarrierDemo4 { private final static int NUM = 3; public static void main(String[] args) { final CyclicBarrier barrier = new CyclicBarrier(NUM,new Runnable(){ @Override public void run() { try { TimeUnit.SECONDS.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " 执行barrier自带的任务!"); } }); for(int i=0;i<NUM;i++){ new Task(barrier).start(); } } static class Task extends Thread{ private CyclicBarrier barrier; public Task(CyclicBarrier barrier){ this.barrier = barrier; } @Override public void run() { System.out.println(Thread.currentThread().getName() + " 初始化开始。。。"); try { Thread.sleep(2000); System.out.println(Thread.currentThread().getName() + " 初始化结束,等待其他task初始化结束,然后再继续运行!"); barrier.await(); } catch (InterruptedException e) { e.printStackTrace(); } catch (BrokenBarrierException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " 其他task初始化结束,开始运行!"); } } }
运行结果如下:
Thread-1 初始化开始。。。Thread-0 初始化开始。。。Thread-2 初始化开始。。。Thread-1 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-0 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-2 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-0 执行barrier自带的任务!Thread-0 其他task初始化结束,开始运行!Thread-1 其他task初始化结束,开始运行!Thread-2 其他task初始化结束,开始运行!
在线程中我故意将CyclicBarrier 中的sleep时间设置的相当长,发现结果是这样的。
当所有线程都到达barrier之后,然后调用CyclicBarrier自带的Runnable里面的run方法。
最后才是所有线程等待结束开始继续运行。
至于是哪个线程来执行CyclicBarrier对象中的任务就需要我们看下源码的实现了,在API文档上看到的是:最后一个进入到barrier的线程将执行。在源码中我们可以看到确实是最后一个线程来运行的,可以看后面的源码分析。
例子5
这个例子来看下,当创建CyclicBarrier对象时,指定一个Runnable对象。即利用CyclicBarrier(int parties, Runnable barrierAction) 构造函数来构造一个对象。
当最后一个进行barrier处的线程执行barrierAction时耗时特别长,且每个线程调用的是await(time,TimeUnit);会不会抛异常
public class CyclicBarrierDemo5 { private final static int NUM = 3; public static void main(String[] args) { final CyclicBarrier barrier = new CyclicBarrier(NUM,new Runnable(){ @Override public void run() { try { TimeUnit.SECONDS.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " 执行barrier自带的任务!"); } }); for(int i=0;i<NUM;i++){ new Task(barrier).start(); } } static class Task extends Thread{ private CyclicBarrier barrier; public Task(CyclicBarrier barrier){ this.barrier = barrier; } @Override public void run() { System.out.println(Thread.currentThread().getName() + " 初始化开始。。。"); try { Thread.sleep(2000); System.out.println(Thread.currentThread().getName() + " 初始化结束,等待其他task初始化结束,然后再继续运行!"); barrier.await(2,TimeUnit.SECONDS);//等待两秒 } catch (InterruptedException e) { e.printStackTrace(); } catch (BrokenBarrierException e) { e.printStackTrace(); } catch (TimeoutException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " 其他task初始化结束,开始运行!"); } } }
运行结果:
Thread-1 初始化开始。。。Thread-0 初始化开始。。。Thread-2 初始化开始。。。Thread-1 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-0 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-2 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-0 执行barrier自带的任务! Thread-0 其他task初始化结束,开始运行!Thread-1 其他task初始化结束,开始运行!Thread-2 其他task初始化结束,开始运行!
当代码换成barrier.await(2,TimeUnit.SECONDS);虽然此时CyclicBarrier对象中的Runnable的执行时间为20s,但是不会抛任何异常。这说明barrier.await(time,TimeUnit)方法等待的其它线程到达barrier的时间,而不包括执行CyclicBarrier对象中的Runnable的时间,在源码分析中,会介绍到。
例子6:CyclicBarrier指定的任务被运行时发生了异常
可能有人会考虑这样一个问题。
当我们利用CyclicBarrier(int parties, Runnable barrierAction) 构造函数指定barrierAction构造CyclicBarrier对象时,如果当最后一个到达barrier的线程执行barrierAction发生异常了会出现怎么样的结果呢??
看下面这个例子你就明白了
public class CyclicBarrierDemo6 { private final static int NUM = 3; public static void main(String[] args) { final CyclicBarrier barrier = new CyclicBarrier(NUM,new Runnable(){ @Override public void run() { System.out.println(Thread.currentThread().getName() + " 执行barrier自带的任务!此任务会抛异常"); int a = 1/0;//故意抛异常 } }); for(int i=0;i<NUM;i++){ new Task(barrier).start(); } } static class Task extends Thread{ private CyclicBarrier barrier; public Task(CyclicBarrier barrier){ this.barrier = barrier; } @Override public void run() { System.out.println(Thread.currentThread().getName() + " 初始化开始。。。"); try { Thread.sleep(2000); System.out.println(Thread.currentThread().getName() + " 初始化结束,等待其他task初始化结束,然后再继续运行!"); barrier.await(); } catch (InterruptedException e) { e.printStackTrace(); } catch (BrokenBarrierException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " 其他task初始化结束,开始运行!"); } } }
运行结果:
Thread-1 初始化开始。。。Thread-0 初始化开始。。。Thread-2 初始化开始。。。Thread-1 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-0 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-2 初始化结束,等待其他task初始化结束,然后再继续运行!Thread-0 执行barrier自带的任务!此任务会抛异常Thread-2 其他task初始化结束,开始运行!Thread-1 其他task初始化结束,开始运行!Exception in thread "Thread-0" java.util.concurrent.BrokenBarrierException at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250) at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362) at com.wrh.readwritelock.CyclicBarrierDemo6$Task.run(CyclicBarrierDemo6.java:42)java.util.concurrent.BrokenBarrierException at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250) at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362) at com.wrh.readwritelock.CyclicBarrierDemo6$Task.run(CyclicBarrierDemo6.java:42)java.lang.ArithmeticException: / by zero at com.wrh.readwritelock.CyclicBarrierDemo6$1.run(CyclicBarrierDemo6.java:16) at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:220) at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362) at com.wrh.readwritelock.CyclicBarrierDemo6$Task.run(CyclicBarrierDemo6.java:42)
结论:当所有线程都到达barrier之后,然后调用CyclicBarrier自带的Runnable里面的run方法。
最后才是所有线程等待结束开始继续运行。当barrier 的任务抛异常,则只会在当前线程中传播,其它线程没有影响继续正常运行。
小结
需要我们了解的知识点有以下几点:
1、CyclicBarrier的用途是让一组线程互相等待,直到到达某个公共屏障点才开始继续工作。
2、CyclicBarrier是可以重复利用的,CountDownLatch不可以重复利用
3、在等待的只要有一个线程发生中断,则其它线程就会被唤醒继续正常运行。
4、CyclicBarrier指定的任务是进行barrier处最后一个线程来调用的,如果在执行这个任务发生异常时,则会传播到此线程,其它线程不受影响继续正常运行。
受篇幅限制,源码分析见下一篇博文哈。下一篇博文地址:http://blog.csdn.net/u010412719/article/details/52160438
- 《Java源码分析》:CyclicBarrier(part one)
- 《Java源码分析》:CyclicBarrier(part two)
- Java 并发 --- CyclicBarrier源码分析
- jdk 源码分析(16)java CyclicBarrier 源码解析
- Java多线程系列(八)—CyclicBarrier源码分析
- Java多线程 -- JUC包源码分析11 -- CyclicBarrier源码分析
- 源码分析-CyclicBarrier
- CyclicBarrier源码分析
- Java coding style - Part One
- JUC源码分析12-locks-CyclicBarrier
- 【Java8源码分析】并发包-CyclicBarrier
- 我的第一次...考试分析 part one
- ELF解析(part one)
- CyclicBarrier源码
- Java Code To Byte Code - Part One
- 【Java】10.CyclicBarrier使用与分析
- JAVA多线程之(CyclicBarrier)
- Glide加载图片流程(Part One)
- HDOJ 5236 Article
- 【Linux系统编程】线程的基本操作
- Android 自定义Animation实现View摇摆效果
- 观察者模式
- 第2章 字符和字符串处理
- 《Java源码分析》:CyclicBarrier(part one)
- Junit4参数化测试
- React native for Android [原理剖析]
- Codeforces 86D Powerful Array [莫队算法]
- 留言板之编辑和查询模块
- 176.You executed this command to create a temporary table: SQL> CREATE GLOBAL TEMPORARY TABLE report
- 【Linux系统编程】线程堆栈大小的使用介绍
- Glide原理分析(二)
- Android Studio 引入第三方jar包