CyclicBarrier 辅助工具类

最新推荐文章于 2022-03-26 17:40:12 发布

colie_li

最新推荐文章于 2022-03-26 17:40:12 发布

阅读量581

点赞数

分类专栏： java线程

本文链接：https://blog.csdn.net/liyantianmin/article/details/42830639

版权

java线程专栏收录该内容

68 篇文章 0 订阅

订阅专栏

一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环的 barrier。CyclicBarrier 支持一个可选的 Runnable 命令，在一组线程中的最后一个线程到达之后（但在释放所有线程之前），该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新共享状态，此屏障操作很有用。

CyclicBarrier介绍（一）
一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环的 barrier。CyclicBarrier 支持一个可选的 Runnable 命令，在一组线程中的最后一个线程到达之后（但在释放所有线程之前），该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新共享状态，此屏障操作很有用。
主要方法：

 
  //设置parties、count及barrierCommand属性。   
 CyclicBarrier(int):   
   
 //当await的数量到达了设定的数量后，首先执行该Runnable对象。   
 CyclicBarrier(int,Runnable):   
   
 //通知barrier已完成线程   
 await():  
 

//设置parties、count及barrierCommand属性。
CyclicBarrier(int):

//当await的数量到达了设定的数量后，首先执行该Runnable对象。
CyclicBarrier(int,Runnable):

//通知barrier已完成线程
await():

应用场景
在某种需求中，比如一个大型的任务，常常需要分配好多子任务去执行，只有当所有子任务都执行完成时候，才能执行主任务，这时候，就可以选择CyclicBarrier了。

CyclicBarrier 表示大家彼此等待，大家集合好后才开始出发，分散活动后又在i指定地点集合碰面，这就好比整个公司的人员利用周末时间集体郊游一样，先各自从家出发到公司集合后，再同时出发到公园游玩，在指定地点集合后再同时开始就餐……

public class CyclicBarrierTest {

	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		final  CyclicBarrier cb = new CyclicBarrier(3);
		for(int i=0;i<3;i++){
			Runnable runnable = new Runnable(){
					public void run(){
					try {
						Thread.sleep((long)(Math.random()*10000));	
						System.out.println("线程" + Thread.currentThread().getName() + 
								"即将到达集合地点1，当前已有" + (cb.getNumberWaiting()+1) + "个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));						
						cb.await();
						
						Thread.sleep((long)(Math.random()*10000));	
						System.out.println("线程" + Thread.currentThread().getName() + 
								"即将到达集合地点2，当前已有" + (cb.getNumberWaiting()+1) + "个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));
						cb.await();	
						Thread.sleep((long)(Math.random()*10000));	
						System.out.println("线程" + Thread.currentThread().getName() + 
								"即将到达集合地点3，当前已有" + (cb.getNumberWaiting() + 1) + "个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));						
						cb.await();						
					} catch (Exception e) {
						e.printStackTrace();
					}				
				}
			};
			service.execute(runnable);
		}
		service.shutdown();
	}
}

线程pool-1-thread-3即将到达集合地点1，当前已有1个已经到达，正在等候
线程pool-1-thread-1即将到达集合地点1，当前已有2个已经到达，正在等候
线程pool-1-thread-2即将到达集合地点1，当前已有3个已经到达，都到齐了，继续走啊
线程pool-1-thread-1即将到达集合地点2，当前已有1个已经到达，正在等候
线程pool-1-thread-3即将到达集合地点2，当前已有2个已经到达，正在等候
线程pool-1-thread-2即将到达集合地点2，当前已有3个已经到达，都到齐了，继续走啊
线程pool-1-thread-3即将到达集合地点3，当前已有1个已经到达，正在等候
线程pool-1-thread-1即将到达集合地点3，当前已有2个已经到达，正在等候
线程pool-1-thread-2即将到达集合地点3，当前已有3个已经到达，都到齐了，继续走啊

public class CyclicBarrierTest implements Runnable {
    private static CyclicBarrier cycli = new CyclicBarrier(10,new TestRun());
    private String name;
    @Override
    public void run() {
        try {
            Thread.sleep((long)(Math.random()*1000));
            System.out.println(Thread.currentThread().getName()+"--到达");
            cycli.await();
            Thread.sleep((long)(Math.random()*1000));
            System.out.println(Thread.currentThread().getName()+"--任务Done");
            cycli.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        ExecutorService exec = Executors.newFixedThreadPool(10);
        CyclicBarrierTest test = new CyclicBarrierTest();
        for(int i=0;i<10;i++){
            exec.submit(test);
        }
    }
}
 class TestRun implements Runnable{
    public boolean flag =false;
    @Override
    public void run() {
        if(flag){
            System.out.println(Thread.currentThread().getName()+" 任务完成..");
        }
        else {
            System.out.println(Thread.currentThread().getName()+" 集合完毕!");
            flag = true;
        }
    }
}

pool-1-thread-2--到达
pool-1-thread-5--到达
pool-1-thread-1--到达
pool-1-thread-8--到达
pool-1-thread-6--到达
pool-1-thread-3--到达
pool-1-thread-7--到达
pool-1-thread-9--到达
pool-1-thread-10--到达
pool-1-thread-4--到达
pool-1-thread-4 集合完毕!
pool-1-thread-6--任务Done
pool-1-thread-4--任务Done
pool-1-thread-8--任务Done
pool-1-thread-5--任务Done
pool-1-thread-2--任务Done
pool-1-thread-10--任务Done
pool-1-thread-9--任务Done
pool-1-thread-7--任务Done
pool-1-thread-1--任务Done
pool-1-thread-3--任务Done
pool-1-thread-3 任务完成..

当被中断的时候：

会抛出中断异常和栅栏坏掉的异常。比如需要等待10个线程全部就位之后才会进行执行，那么当其中一个线程被中断后，另外的9个线程会抛出栅栏坏掉的异常,不会做无穷的等待。

public class CyclicBarrierTest implements Runnable {
    private static CyclicBarrier cycli = new CyclicBarrier(10,new TestRun());
    private String name;
    @Override
    public void run() {
        try {
            System.out.println(Thread.currentThread().getName()+"--到达");
            cycli.await();
            System.out.println(Thread.currentThread().getName()+"--任务Done");
            cycli.await();
        } catch (InterruptedException e) {
           // e.printStackTrace();
            System.out.println(Thread.currentThread().getName()+"--被中断!!!");
        } catch (BrokenBarrierException e) {
           // e.printStackTrace();
            System.out.println(Thread.currentThread().getName()+"-栅栏被破坏!!!");
        }
    }

    public static void main(String[] args) {
        ExecutorService exec = Executors.newFixedThreadPool(10);
        CyclicBarrierTest test = new CyclicBarrierTest();
        for(int i=0;i<10;i++){
            Thread t1 = new Thread(test);
            //exec.submit(test);
            t1.start();
            if(i==8){
                t1.interrupt();
            }
        }
    }
}
 class TestRun implements Runnable{
    public boolean flag =false;
    @Override
    public void run() {
        if(flag){
            System.out.println(Thread.currentThread().getName()+" 任务完成..");
        }
        else {
            System.out.println(Thread.currentThread().getName()+" 集合完毕!");
            flag = true;
        }
    }
}

Thread-0--到达
Thread-1--到达
Thread-2--到达
Thread-3--到达
Thread-4--到达
Thread-5--到达
Thread-6--到达
Thread-7--到达
Thread-8--到达
Thread-8--被中断!!!
Thread-3-栅栏被破坏!!!
Thread-5-栅栏被破坏!!!
Thread-7-栅栏被破坏!!!
Thread-0-栅栏被破坏!!!
Thread-2-栅栏被破坏!!!
Thread-1-栅栏被破坏!!!
Thread-6-栅栏被破坏!!!
Thread-4-栅栏被破坏!!!
Thread-9--到达
Thread-9-栅栏被破坏!!!