对于程序中的多线程并发控制，总是有些繁琐，比如，如何让多个线程处于等待状态，又可以有条不紊的运行，或者如何让多个线程如同集会一样开始工作。但作为Java程序员，我们应该感到庆幸，因为java为我们提供一些类，使得原本可能无从下手的问题变得简单，同时也大大的提高了开发的效率。介绍一下允许对多个线程计时使得运行有序的CountDownLatch、CycliBarrier


先看一下CountDownLatch几个方法

CountDownLatch(int count)

void await() 让当前对象处于等待状态

boolean await(long timeout, TimeUnit unit) 使线程在给定时间内等待，知道此对象count为0

void countDown()使count减一，为零开始执行当前线程

getCount()获得count值

计数无法被重置，只能使用一次，需要时要重新定义。

应用场合：需要等待某个条件达到要求后才能做后面的事情；同时当线程都完成后也会触发事件，以便进行后面的操作。 这个时候就可以使用CountDownLatch。CountDownLatch最重要的方法是countDown()和await()，前者主要是倒数一次，后者是等待倒数到0，如果没有到达0，就只有阻塞等待了。


看一下下面例子

//五个人吃大餐，吃完了付款
public class TestCountDownLatch
{
	public static void main(String[] args) throws InterruptedException
	{
		
		final CountDownLatch start = new CountDownLatch(1);
		final CountDownLatch end = new CountDownLatch(5);
		
		//开启一个线程池
		ExecutorService exc =  Executors.newFixedThreadPool(5);
		
		for(int i=0; i<5; i++)
		{
			final int no = i+1;
			
			Runnable run = new Runnable()
			{
				
				@SuppressWarnings("static-access")
				@Override
				public void run()
				{
					try
					{
						Thread.currentThread().sleep((long)(Math.random()*10000));
						start.await();
					}
					catch (InterruptedException e)
					{
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					finally
					{
						System.out.println("第"+no+"个人吃完了");
						
						end.countDown();
					}
				}
			};
			
			exc.submit(run);
		}
		System.out.println("大餐开始了！");
		start.countDown();
		
		//直到count为0时，才开始执行
		end.await();
		System.out.println("所有人都吃饱了，可以付款了");
		
	}
}



运行结果：

大餐开始了！

第5个人吃完了

第2个人吃完了

第3个人吃完了

第4个人吃完了

第1个人吃完了

所有人都吃饱了，可以付款了


在介绍一下CycliBarrier

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

同时，CyclicBarrier允许多次重复使用


下面，看一个CycliBarrier的例子


//下面是一个模拟以百米比赛
public class TestCycliBarrier
{

	public static void main(String[] args)
	{
		CyclicBarrier barrier = new CyclicBarrier(5);

		System.out.println("现在进行一百米比赛");

		// 初始化一个线程池
		ExecutorService es = Executors.newFixedThreadPool(5);
		es.submit(new MyRunnable("第1个人", barrier));
		es.submit(new MyRunnable("第2个人", barrier));
		es.submit(new MyRunnable("第3个人", barrier));
		es.submit(new MyRunnable("第4个人", barrier));
		es.submit(new MyRunnable("第5个人", barrier));

	}
}

class MyRunnable implements Runnable
{
	// 一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点
	private CyclicBarrier barrier;

	private String name;

	public MyRunnable(String name, CyclicBarrier barrier)
	{
		this.name = name;
		this.barrier = barrier;
	}

	@Override
	public void run()
	{
		try
		{
			Thread.sleep(1000 * (new Random()).nextInt(8));
			System.out.println(name + "准备好了");
			// 调用barrier的await方法，在所有参与者都已经到此 barrier之前，将一直阻塞等待。
			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(name + "起跑");
	}
}



运行结果：

现在进行一百米比赛
第4个人准备好了
第2个人准备好了
第5个人准备好了
第1个人准备好了
第3个人准备好了
第3个人起跑
第4个人起跑
第5个人起跑
第2个人起跑
第1个人起跑