Java中CycliBarriar和CountdownLatch区别(附测试实例)

CyclicBarrier和CountdownLatch是java 1.5中提供的一些非常有用的辅助类来帮助我们进行并发编程。

这两个的区别是CyclicBarrier可以重复使用已经通过的障碍，而CountdownLatch不能重复使用。

CountdownLatch: 

一个线程(或者多个)，等待另外N个线程完成某个事情之后才能执行。是并发包中提供的一个可用于控制多个线程同时开始某个动作的类，其采用的方法为减少计数的方式，当计数减至零时位于latch.Await()后的代码才会被执行，CountDownLatch是减计数方式，计数==0时释放所有等待的线程；CountDownLatch当计数到0时，计数无法被重置；

CyclicBarrier:

字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。 即:N个线程相互等待，任何一个线程完成之前，所有的线程都必须等待。CyclicBarrier是当await的数量到达了设置的数量的时候，才会继续往下面执行，CyclicBarrier计数达到指定值时，计数置为0重新开始。

对于CountDownLatch来说，重点是那个“一个线程”,是它在等待，而另外那N的线程在把“某个事情”做完之后可以继续等待，可以终止。而对于CyclicBarrier来说，重点是那N个线程，他们之间任何一个没有完成，所有的线程都必须等待。

CountdownLatch测试类：

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

/**
 * 测试多个线程结束后开始线程
 */
public class TestCountDownLatch {
	public static void main(String[] args) throws Exception {
		CountDownLatch countDownLatch = new CountDownLatch(5);
		Executor executor = Executors.newFixedThreadPool(5);
		//测试阻塞其他线程
		 new Thread(new MyRunnable(countDownLatch)).start();
		 //为了测试效果进行线程休眠
	 	Thread.sleep(1000);
		 for(int i = 1;i<=5;i++){
		 		countDownLatch.countDown();
		 		System.out.println("第"+i+"调用countDown方法结束");
		 		//为了测试效果进行线程休眠
		 		Thread.sleep(1000);
		 }
		
		/*
		 * 测试阻塞主线程
		
		for (int i = 1; i <= 5; i++) {
			new Thread(new MyRunnable1(countDownLatch,i+"")).start();
			Thread.sleep(1000);
		}
		try {
			System.out.println("主线程阻塞");
			countDownLatch.await();
			System.out.println("主线程继续执行");
		} catch (InterruptedException e) {
			e.printStackTrace();
		} */

	}

}

class MyRunnable implements Runnable {
	CountDownLatch countDownLatch;

	public MyRunnable(CountDownLatch countDownLatch) {
		this.countDownLatch = countDownLatch;
	}

	@Override
	public void run() {
		try {
			System.out.println("进入线程，即将进入阻塞状态");
			//调用await进行线程阻塞
			countDownLatch.await();
			System.out.println("线程进行执行...");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

class MyRunnable1 implements Runnable {
	private CountDownLatch countDownLatch;
	private String mark;

	public MyRunnable1(CountDownLatch countDownLatch, String mark) {
		super();
		this.countDownLatch = countDownLatch;
		this.mark = mark;
	}

	@Override
	public void run() {
		System.out.println(mark+"号线程开始");
		try {
			//使线程休眠，看到更好的测试效果
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(mark+"号线程结束");
		//调用CountDownLatch的countDown方法进行次数减1
		countDownLatch.countDown();
	}

	public CountDownLatch getCountDownLatch() {
		return countDownLatch;
	}

	public void setCountDownLatch(CountDownLatch countDownLatch) {
		this.countDownLatch = countDownLatch;
	}

	public String getMark() {
		return mark;
	}

	public void setMark(String mark) {
		this.mark = mark;
	}

}

CyclicBarrier 测试类：

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
/**
 * 测试CyclicBarrier类的使用
 */
public class TestCyclicBarrier {
	static final Integer NUM = 5;
	public static void main(String[] args) throws InterruptedException {
		//实例CyclicBarrier对象
		CyclicBarrier cyclicBarrier = new CyclicBarrier(NUM);
		//实例化一个固定大小线程池
		Executor executor = Executors.newFixedThreadPool(NUM);
		for(int i = 1;i<=NUM;i++){
			//执行线程
			executor.execute(new MyRunnale(cyclicBarrier,i+"号"));
			//为了更好的效果，休眠一秒
			Thread.sleep(1000);
		}
		System.out.println("指令通知完成");
	}
}


class MyRunnale implements Runnable{
	private CyclicBarrier cyclicBarrier;
	private String mark;
	public MyRunnale(CyclicBarrier cyclicBarrier,String mark) {
		super();
		this.cyclicBarrier = cyclicBarrier;
		this.mark = mark;
	}
	@Override
	public void run() {
		System.out.println(mark+"进入线程,线程阻塞中...");
		try {
			// barrier的await方法，在所有参与者都已经在此 barrier 上调用 await 方法之前，将一直等待。
			cyclicBarrier.await();
			Thread.sleep(2000);//为了看到更好的效果，线程阻塞两秒
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (BrokenBarrierException e) {
			e.printStackTrace();
		}
		
		System.out.println(mark+"线程阻塞结束,继续执行...");
		
	}
	public CyclicBarrier getCyclicBarrier() {
		return cyclicBarrier;
	}

	public void setCyclicBarrier(CyclicBarrier cyclicBarrier) {
		this.cyclicBarrier = cyclicBarrier;
	}

}

总结:
  

CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：

CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；

而CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；

另外，CountDownLatch是不能够重用的，而CyclicBarrier是可以重用的。