CyclicBarrier的工作原理及其实例

        CyclicBarrier是多线程中一个重要的类,主要用于线程组内部之间的线程的相互等待问题。

 1.CyclicBarrier的工作原理      

        CyclicBarrier大致是可循环利用的屏障,顾名思义,这个名字也将这个类的特点给明确地表示出来了。首先,便是可重复利用,说明该类创建的对象可以复用;其次,屏障则体现了该类的原理:每个线程执行时,都会碰到一个屏障,直到所有线程执行结束,然后屏障便会打开,使所有线程继续往下执行。

        这里介绍CyclicBarrier的两个构造函数:CyclicBarrier(int parties)和CyclicBarrier(int parties, Runnable barrierAction) :前者只需要声明需要拦截的线程数即可,而后者还需要定义一个等待所有线程到达屏障优先执行的Runnable对象。

        实现原理:在CyclicBarrier的内部定义了一个Lock对象,每当一个线程调用await方法时,将拦截的线程数减1,然后判断剩余拦截数是否为初始值parties,如果不是,进入Lock对象的条件队列等待。如果是,执行barrierAction对象的Runnable方法,然后将锁的条件队列中的所有线程放入锁等待队列中,这些线程会依次的获取锁、释放锁。

        举例说明:如果一个寝室四个人约好了去球场打球,由于四个人准备工作不同,所以约好在楼下集合,并且四个人集合好之后一起出发去球场。

package concurrent;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.*;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.*;
public class CyclicBarrierDemo {
	private static final ThreadPoolExecutor threadPool=new ThreadPoolExecutor(4,10,60,TimeUnit.SECONDS,new LinkedBlockingQueue<Runnable>());
	//当拦截线程数达到4时,便优先执行barrierAction,然后再执行被拦截的线程。
	private static final CyclicBarrier cb=new CyclicBarrier(4,new Runnable() {
		public void run()
		{
			System.out.println("寝室四兄弟一起出发去球场");
		}
	});
	private static class GoThread extends Thread{
		private final String name;
		public GoThread(String name)
		{
			this.name=name;
		}
		public void run()
		{
			System.out.println(name+"开始从宿舍出发");
			try {
				Thread.sleep(1000);
				cb.await();//拦截线程
				System.out.println(name+"从楼底下出发");
				Thread.sleep(1000);
				System.out.println(name+"到达操场");
				
			}
			catch(InterruptedException e)
			{
				e.printStackTrace();
			}
			catch(BrokenBarrierException e)
			{
				e.printStackTrace();
			}
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String[] str= {"李明","王强","刘凯","赵杰"};
		for(int i=0;i<4;i++)
		{
			threadPool.execute(new GoThread(str[i]));
		}
		try
		{
			Thread.sleep(4000);
			System.out.println("四个人一起到达球场,现在开始打球");
		}
		catch(InterruptedException e)
		{
			e.printStackTrace();
		}
		

	}

}

运行程序,得到如下结果:

李明开始从宿舍出发
赵杰开始从宿舍出发
王强开始从宿舍出发
刘凯开始从宿舍出发
寝室四兄弟一起出发去球场
赵杰从楼底下出发
李明从楼底下出发
刘凯从楼底下出发
王强从楼底下出发
赵杰到达操场
王强到达操场
李明到达操场
刘凯到达操场
四个人一起到达球场,现在开始打球

        以上便是CyclicBarrier使用实例,通过await()方法对线程的拦截,拦截数加1,当拦截数为初始的parties,首先执行了barrierAction,然后对拦截的线程队列依次进行获取锁释放锁。接下来,在这个例子上讲解CyclicBarrier对象的复用特性。

package concurrent;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.*;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.*;
public class CyclicBarrierDemo {
	private static final ThreadPoolExecutor threadPool=new ThreadPoolExecutor(4,10,60,TimeUnit.SECONDS,new LinkedBlockingQueue<Runnable>());
	//当拦截线程数达到4时,便优先执行barrierAction,然后再执行被拦截的线程。
	private static final CyclicBarrier cb=new CyclicBarrier(4,new Runnable() {
		public void run()
		{
			System.out.println("寝室四兄弟一起出发去球场");
		}
	});
	private static class GoThread extends Thread{
		private final String name;
		public GoThread(String name)
		{
			this.name=name;
		}
		public void run()
		{
			System.out.println(name+"开始从宿舍出发");
			try {
				Thread.sleep(1000);
				cb.await();//拦截线程
				System.out.println(name+"从楼底下出发");
				Thread.sleep(1000);
				System.out.println(name+"到达操场");
				
			}
			catch(InterruptedException e)
			{
				e.printStackTrace();
			}
			catch(BrokenBarrierException e)
			{
				e.printStackTrace();
			}
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String[] str= {"李明","王强","刘凯","赵杰"};
		String[] str1= {"王二","洪光","雷兵","赵三"};
		for(int i=0;i<4;i++)
		{
			threadPool.execute(new GoThread(str[i]));
		}
		try
		{
			Thread.sleep(4000);
			System.out.println("四个人一起到达球场,现在开始打球");
			System.out.println("现在对CyclicBarrier进行复用.....");
			System.out.println("又来了一拨人,看看愿不愿意一起打:");
		}
		catch(InterruptedException e)
		{
			e.printStackTrace();
		}
		//进行复用:
		for(int i=0;i<4;i++)
		{
			threadPool.execute(new GoThread(str1[i]));
		}
		try
		{
			Thread.sleep(4000);
			System.out.println("四个人一起到达球场,表示愿意一起打球,现在八个人开始打球");
			//System.out.println("现在对CyclicBarrier进行复用");
		}
		catch(InterruptedException e)
		{
			e.printStackTrace();
		}
		
		

	}

}

运行如下程序,得到:

王强开始从宿舍出发
赵杰开始从宿舍出发
李明开始从宿舍出发
刘凯开始从宿舍出发
寝室四兄弟一起出发去球场
王强从楼底下出发
李明从楼底下出发
刘凯从楼底下出发
赵杰从楼底下出发
王强到达操场
李明到达操场
赵杰到达操场
刘凯到达操场
四个人一起到达球场,现在开始打球
现在对CyclicBarrier进行复用.....
又来了一拨人,看看愿不愿意一起打:
王二开始从宿舍出发
雷兵开始从宿舍出发
洪光开始从宿舍出发
赵三开始从宿舍出发
寝室四兄弟一起出发去球场
洪光从楼底下出发
王二从楼底下出发
雷兵从楼底下出发
赵三从楼底下出发
雷兵到达操场
赵三到达操场
洪光到达操场
王二到达操场
四个人一起到达球场,表示愿意一起打球,现在八个人开始打球

        由上面实例可了解CyclicBarrier的工作原理以及复用的特性。

2.通过CountDownLatch实现CyclicBarrier

        CountDownLatch通过将await()方法和countDown()方法在不同线程组分别调用,从而实现线程组间的线程等待,即一个线程组等待另一个线程组执行结束再执行。而CyclicBarrier类则是通过调用await()方法实现线程组内的线程等待,即达到需要拦截的线程数,被拦截的线程才会依次获取锁,释放锁。那么将CountDownLatch的用法进行转换,即在同一个线程组内调用await()方法和countDown()方法,则可实现CyclicBarrier类的功能。但是注意的是必须先调用countDown()方法,才能调用await()方法,因为一旦调用await()方法,该线程后面的内容便不再执行,那么count值无法改变。具体代码如下:

package concurrent;

import java.util.Vector;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class CyclicBarrierWithCount {
	private final static CountDownLatch cdl=new CountDownLatch(3);
	private final static ThreadPoolExecutor threadPool= new ThreadPoolExecutor(10, 15, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());//使用线程池
	
	private static class GoThread extends Thread{
		private final String name;
		
		public GoThread(String name)
		{
			this.name=name;
			
		}
		public void run()
		{
			System.out.println(name+"开始从宿舍出发");
			cdl.countDown();
			try
			{
				Thread.sleep(1000);
				cdl.await();//拦截线程
				System.out.println(name+"从楼底下出发");
				Thread.sleep(1000);
				System.out.println(name+"到达操场");
			}
			catch(InterruptedException e)
			{
				e.printStackTrace();
			}

			
			
		}
	}
	

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		
		String[] str= {"李明","王强","刘凯","赵杰"};
		String[] str1= {"王二","洪光","雷兵","赵三"};
		for(int i=0;i<4;i++)
		{
			threadPool.execute(new GoThread(str[i]));
		}
		try
		{
			Thread.sleep(4000);
			System.out.println("四个人一起到达球场,现在开始打球");
			System.out.println("现在对CyclicBarrier进行复用.....");
			System.out.println("又来了一拨人,看看愿不愿意一起打:");
		}
		catch(InterruptedException e)
		{
			e.printStackTrace();
		}
		for(int i=0;i<4;i++)
		{
			threadPool.execute(new GoThread(str1[i]));
		}
		try
		{
			Thread.sleep(4000);
			System.out.println("四个人一起到达球场,表示愿意一起打球,现在八个人开始打球");
			//System.out.println("现在对CyclicBarrier进行复用");
		}
		catch(InterruptedException e)
		{
			e.printStackTrace();
		}
	}

}

执行上述代码,结果如下:

李明开始从宿舍出发
赵杰开始从宿舍出发
王强开始从宿舍出发
刘凯开始从宿舍出发
王强从楼底下出发
刘凯从楼底下出发
李明从楼底下出发
赵杰从楼底下出发
李明到达操场
赵杰到达操场
王强到达操场
刘凯到达操场
四个人一起到达球场,现在开始打球
现在对CyclicBarrier进行复用.....
又来了一拨人,看看愿不愿意一起打:
王二开始从宿舍出发
洪光开始从宿舍出发
雷兵开始从宿舍出发
赵三开始从宿舍出发
王二从楼底下出发
洪光从楼底下出发
雷兵从楼底下出发
赵三从楼底下出发
洪光到达操场
王二到达操场
雷兵到达操场
赵三到达操场
四个人一起到达球场,表示愿意一起打球,现在八个人开始打球
        由上面可知,CountDownLatch一定情况下可以实现CyclicBarrier类的功能。


3.CountDownLatch和CyclicBarrier的比较

1.CountDownLatch是线程组之间的等待,即一个(或多个)线程等待N个线程完成某件事情之后再执行;而CyclicBarrier则是线程组内的等待,即每个线程相互等待,即N个线程都被拦截之后,然后依次执行。

2.CountDownLatch是减计数方式,而CyclicBarrier是加计数方式。

3.CountDownLatch计数为0无法重置,而CyclicBarrier计数达到初始值,则可以重置。

4.CountDownLatch不可以复用,而CyclicBarrier可以复用。

评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值