JAVA多线程CyclicBarrier应用

参考：http://blog.csdn.net/turkeyzhou/article/details/5733242

 一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。

代码如下：

public class BarrierAction implements Runnable {

	@Override
	public void run() {
		System.out.println("全部线程已执行完毕！");
	}
}

 

import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;

/** 
 * CyclicBarrier类似于CountDownLatch也是个计数器， 
 * 不同的是CyclicBarrier数的是调用了CyclicBarrier.await()进入等待的线程数， 
 * 当线程数达到了CyclicBarrier初始时规定的数目时，所有进入等待状态的线程被唤醒并继续。 
 * CyclicBarrier就象它名字的意思一样，可看成是个障碍， 
 * 所有的线程必须到齐后才能一起通过这个障碍。 
 * CyclicBarrier初始时还可带一个Runnable的参数， 
 * 此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。 
 */  
public class Worker implements Runnable {

	private int index;
	private CyclicBarrier cyclicBarrier;
	
	public Worker(int index,CyclicBarrier cyclicBarrier) {
		this.index = index;
		this.cyclicBarrier = cyclicBarrier;
	}
	
	@Override
	public void run() {
		System.out.println("第"+ index +"个线程休眠"+(2 * index) +"秒！");
		try {
			TimeUnit.SECONDS.sleep(2 * index);
		} catch (Exception e) {
			
		}
		System.out.println( "第"  + index +  "个线程结束休眠！" );  
		try {
                        // 在这里待，所有线程到达后，才往下执行
			cyclicBarrier.await();
		} catch (Exception e) {
			
		}
                // 所有线程到达后，执行这里
		System.out.println(index);
	}
}

 

import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CyclicBarrierTest {

	private final CyclicBarrier cyclicBarrier;
	private int count;
	
	public CyclicBarrierTest(int count) {
		this.count = count;
		this.cyclicBarrier = new CyclicBarrier(this.count, new BarrierAction());
		
		ExecutorService exec = Executors.newCachedThreadPool();
		for (int i = 0; i < this.count; i++) {
			exec.execute(new Worker(i,cyclicBarrier));
		}
		exec.shutdown();
	}
	
	
	public static void main(String[] args) {
		new CyclicBarrierTest(5);
	}
}

 执行结果如下：

第1个线程休眠2秒！
第4个线程休眠8秒！
第2个线程休眠4秒！
第0个线程休眠0秒！
第0个线程结束休眠！
第3个线程休眠6秒！
第1个线程结束休眠！
第2个线程结束休眠！
第3个线程结束休眠！
第4个线程结束休眠！
全部线程已执行完毕！
0
3
2
4
1

 

评论

2 楼 bo_hai 2014-06-29  

总结：
CountDownLatch 用来等待某个终点状态；
CyclicBarrier用于一组线程互相等待，直到达到某个公共屏障点。

1 楼 bo_hai 2014-06-29  

上面的例子也可以使用CountDownLatch来实例，下面是实现的代码：

import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class WorkerCallable implements Callable<Integer> {

	private final int index;
	private final CountDownLatch countDownLatch;
	
	public WorkerCallable(int index,CountDownLatch countDownLatch) {
		this.index = index;
		this.countDownLatch = countDownLatch;
	}
	
	@Override
	public Integer call() throws Exception {
		System.out.println("第"+ index +"个线程休眠"+(2) +"秒！"); 
		try {
			TimeUnit.SECONDS.sleep(2L);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println( "第"  + index +  "个线程结束休眠！" ); 
		countDownLatch.countDown();
		return index;
	}

}

WorkerTest的代码如下：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class WorkerTest {

	private final int count;
	private final CountDownLatch	countDownLatch;
	
	public WorkerTest(int count) {
		this.count = count;
		this.countDownLatch = new CountDownLatch(count);
	}

	public void doWork() throws Exception{
		ExecutorService exe = Executors.newCachedThreadPool();
		List<Future<Integer>> result = new ArrayList<Future<Integer>>();
		for (int i = 0; i < count ; i++) {
			result.add(exe.submit(new WorkerCallable(i,countDownLatch)));
		}
		exe.shutdown();
		countDownLatch.await();
		System.out.println("全部线程已执行完毕！"); 
		for (Future<Integer> future : result) {
			System.out.println(future.get());
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception {
		new WorkerTest(5).doWork();
	}
}