CyclicBarrier的使用

[size=x-large]一、应用背景[/size]

[size=medium]在实际的应用中，我们有时候需要启动多个线程来完成一项任务，而且要求多个线程在到达某一个点的时候停下来，等待所有的线程都到达这个点之后继续各自向下运行，这时候java.util.concurrent.CyclicBarrier就派上用场了。这里最重要的方法就是 await() ，当所有的线程都调用了该方法之后，这些线程才可以继续向下运行，否则将处于等待，等待所有的线程都调用这个方法。


案例，通过多线程统计一组数据：[/size]

package com.sino.thread;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo implements Runnable{

	private int count = 0;

	private int num;

	private CyclicBarrier barrier;

	public CyclicBarrierDemo(CyclicBarrier barrier,int num) {
		this.barrier = barrier;
		this.num = num;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;  i<num; i++) {
			count = count + i;
		}
		System.out.println(Thread.currentThread().getName());
		try {
			barrier.await();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (BrokenBarrierException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+" 累加的和是："+count);
	}

}

测试类：

package com.sino.thread.test;

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

import com.sino.thread.CyclicBarrierDemo;

public class CyclicBarrierTest {

	public static void main(String[] args) {

		Runnable runner = new Runnable(){

			@Override
			public void run() {
				System.out.println("开始计算");
			}

		};
		CyclicBarrier barrier = new CyclicBarrier(2, runner);
		CyclicBarrierDemo demo = new CyclicBarrierDemo(barrier,10);
		ExecutorService exec = Executors.newFixedThreadPool(2);

		Thread t1 = new Thread(demo,"t1");
		Thread t2 = new Thread(demo,"t2");
		exec.submit(t1);
		exec.submit(t2);
		exec.shutdown();
	}
}

运行的结果：

pool-1-thread-1
pool-1-thread-2
开始计算
pool-1-thread-2 累加的和是：90
pool-1-thread-1 累加的和是：90

[size=xx-large]二、说明[/size]


[size=medium]执行到CyclicBarrier barrier = new CyclicBarrier(2, runner);时
Runnable的参数是在CyclicBarrier的数目达到2时并且所有线程调用.await()进入等待且未被唤醒前执行。 从输出结果可以看到，在两个线程都到达await()之后，才进入到runner对应的run方法中，之后两个线程继续向下执行

所以继续执行下面的两个线程
Thread t1 = new Thread(demo,"t1");
Thread t2 = new Thread(demo,"t2");

执行public void run()方法，分别执行，互不影响

执行到barrier.await();时该线程进入等待状态，当两个线程都执行完barrier.await();时，进入到new CyclicBarrier(2, runner);里面的run方法， 执行完里面的方法后，等待的两个线程再次被唤醒，继续各自执行线程后面的语句。 [/size]