Java中CountDownLatch和CyclicBarrier的使用和比较

---

CountDownLatch和CyclicBarrier同为Java1.5开始引入的，应用于多线程编程中的一种工具，二者用途十分相近，十分容易混淆。

CountDownLatch

CountDownLatch用来使一个线程等待其他N个线程执行完毕之后，在执行。在其他N个线程没有执行结束（调用countDown()）之前一直阻塞。其他的N个线程各执行完毕之后各自退出。

例如，老王开了一家夜市店，不断有客人来吃饭，他必须等所有客人吃完饭之后他才能打烊。第一个客人走了，边直接走了，跟第二个客人走不走无关。第二个客人吃完也就自己走了，只有老板一个人在等着所有客人吃完离开，如果过了很晚之后客人还没走（超时了），则强制打烊，代码示例如下：

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

public class CountDownLatchTest {

	public static void main(String[] args) throws InterruptedException {

		final CountDownLatch latch=new CountDownLatch(2);

		Thread t1=new Thread(){
			public void run(){
				try {
					System.out.println("第1桌客人进来吃饭...");
					Thread.sleep(2000);//模拟任务耗时
					System.out.println("第1桌客人进来吃完了...");
					latch.countDown();
				} catch (InterruptedException e) {
				}
			}
		};

		Thread t2=new Thread(){
			public void run(){
				try {
					System.out.println("第2桌客人进来吃饭...");
					Thread.sleep(3000);//模拟任务耗时
					System.out.println("第2桌客人进来吃完了...");
					latch.countDown();
				} catch (InterruptedException e) {
				}
			}
		};
		Thread t3=new Thread(){
			public void run(){
				try {
					System.out.println("我是店主：饭店正在营业，等客人吃完饭之后再打烊...");
					latch.await(15, TimeUnit.SECONDS);
					System.out.println("我是店主：你们已经吃完了，现在该我来收尾工作，然后打烊了...");
				} catch (InterruptedException e) {
				}
			}
		};
		t3.start();
		t1.start();
		t2.start();
	}

}

• 运行结果
  
  第1桌客人进来吃饭...
  
  我是店主：饭店正在营业，等客人吃完饭之后再打烊...
  
  第2桌客人进来吃饭...
  
  第1桌客人进来吃完了...
  
  第2桌客人进来吃完了...
  
  我是店主：你们已经吃完了，现在该我来收尾工作，然后打烊了...

这里启用了3个现场模拟，其中t3是那个等待线程，t3调用latch.await(15, TimeUnit.SECONDS); 之后便开始阻塞，等着t1,t2给信号，根据构造方法的定义CountDownLatch(2) 这里他需要等待的计数为2，t1,t2在执行完毕之后分别调用一次countDown()，而后t3便可以开始执行。假设这里t2调用sleep的时间为20秒，那么t3在等不到t2的countDown() 信号的情况下，会因为到达设置的15秒超时而强制打烊。

CyclicBarrier

CyclicBarrier的作用就是使多个线程达到同一个屏障然后才能继续后续工作。在这个过程中，各个线程是互相等待。大家都到达同一个屏障之后才能继续下一步的工作。

例如，朋友一起聚餐，大家提议要干杯。有人动作快，有人动作慢，动作快的人酒杯已经举起来了，然后就这么举着，等大家陆陆续续的都把杯子酒倒满，陆陆续续的举起来，最终当大家都举起来了之后，一起大喊：干！然后就各自喝了起来。这里的屏障就是大家都把杯子举起来的那一刻，那么在这之前，所有人都是阻塞的状态都在互相做自己的事情，只有当所有人都完成举杯，到达了这个一致的屏障，大家便可以喊：干杯了。代码示例如下：

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

public class CycleBarrierTest {

	public static void main(String[] args) {

		final CyclicBarrier cb=new CyclicBarrier(3);

		Thread t1=new Thread(){
			public void run(){
				try {
					Thread.sleep(2000);
					System.out.println("张三说：我的杯子已经端起来了");
					cb.await();
					System.out.println("张三说：干！");
				} catch (InterruptedException e) {
					e.printStackTrace();
				} catch (BrokenBarrierException e) {
					e.printStackTrace();
				}
			}
		};

		Thread t2=new Thread(){
			public void run(){
				try {
					Thread.sleep(3000);
					System.out.println("李四说：我的杯子已经端起来了");
					cb.await();
					System.out.println("李四说：干！");
				} catch (InterruptedException e) {
					e.printStackTrace();
				} catch (BrokenBarrierException e) {
					e.printStackTrace();
				}
			}
		};

		Thread t3=new Thread(){
			public void run(){
				try {
					Thread.sleep(1000);
					System.out.println("王五说：我的杯子已经端起来了");
					cb.await();
					System.out.println("王五说：干！");
				} catch (InterruptedException e) {
					e.printStackTrace();
				} catch (BrokenBarrierException e) {
					e.printStackTrace();
				}
			}
		};

		t1.start();
		t2.start();
		t3.start();

	}

}

• 运行结果
  
  王五说：我的杯子已经端起来了
  
  张三说：我的杯子已经端起来了
  
  李四说：我的杯子已经端起来了
  
  李四说：干！
  
  王五说：干！
  
  张三说：干！

从运行的结果顺序看出，王五先把杯子举起来了并没有向下执行，打印“干”。而是大家都举起来之后，一起说出了“干”。这边是CyclicBarrier的效果。

这里从够赞函数CyclicBarrier（3）看出初始化计数为3，需要等待三个计数，只有有一个计数没达到那么会一直阻塞下去，如果这里把3改成4，会发现程序没法执行结束而是一直阻塞。

总结

上面两个示例主要展示了，CyclicBarrier和CountDownLatch的用法以及，CyclicBarrier场景下所有线程都在等待彼此达到共同屏障，而CountDownLatch中是一个线程阻塞着等待其他线程的信号。

二者还有一个最大的区别便是：CyclicBarrier可以重用，而CountDownLatch不行。CyclicBarrier中有个reset方法，如下：

返回值类型	方法名	方法描述
void	reset()	Resets the barrier to its initial state.

这个reset（）方法的作用就是重置barrier到它的初始化状态。

CountDownLatch适用于一次性的事件，例如应用程序/模块 启动的时候。CyclicBarrier更适用于那种复发的事件场景。例如，输入数据不断改变时的事实计算。

join()方法有话要说

假设我们新建一个类，并在main函数中启动一个线程t1,然后调用t1.join().那么这个t1.join()方法就会是当前线程等待t1线程，直到t1线程执行结束。看到CountDownLatch，CyclicBarrier的作用之后，不禁要问，join方法也是促使线程等待的。那么join和上面说的二者又有什么区别呢？

CountDownLatch/CyclicBarrier并不要求所有工作线程执行结束，只要应用程序还在运行这些线程可以一直运行下去，也就是说“某一个工作”可以执行多次。此外，如果我们有N个任务，有M个线程，(N大于M)某线程可以执行多次任务，直到他们公共的Barrier N达到0。这个例子可以看出，CountDownLatch/CyclicBarrier更适用于让M个线程来共同完成一项工作的N个任务。

同时，在使用join()的时候，主线程需要在持有其他线程的引用的情况下，并调用join()方法。如果需要join的线程比较多，那么主线程就需要只有多个线程的引用（this is a bit dirty）。而在使用CountDownLatch/CyclicBarrier的时候，多个线程共享一个实例。(this is clear).