线程间控制之CountDownLatch和CyclicBarrier使用介绍

一、CountDownLatch介绍

        CountDownLatch类（采用减法计数）；是一个线程同步辅助工具类和CyclicBarrier类（采用加法计数）功能类似，允许一个或多个线程等待，直到在其他线程中执行的一组操作完成。

二、CountDownLatch俩种应用场景：

        场景一：所有线程在等待开始信号startSignal.await()，主流程发出开始信号通知，既执行startSignal.countDown()方法后，所有线程才开始执行；每个线程执行完发出做完信号，既执行doneSignal.countDown()方法；当所有线程都执行完毕后，主流程才能继续往下执行。   

package ThreadStudy;

import java.util.concurrent.CountDownLatch;

public class Driver1 {
	
	public static void main(String[] args) throws InterruptedException {
		int N = 5;
		CountDownLatch startSignal = new CountDownLatch(1);
		CountDownLatch doneSignal = new CountDownLatch(N);
		for (int i = 0; i < N; i++) {
			new Thread(new Work1(startSignal, doneSignal)).start();
		}
		//此时所有线程处于等待状态
		System.out.println("doSomethingElse()");
		//让所有线程执行
		startSignal.countDown();
		//等待所有线程执行完毕
		doneSignal.await();
		System.out.println("doSomethingElse()");
		
	}
}

class Work1 implements Runnable {
	
	private final CountDownLatch startSignal;
	private final CountDownLatch doneSignal;
	
	public Work1(CountDownLatch startSignal,CountDownLatch doneSignal) {
		this.startSignal=startSignal;
		this.doneSignal= doneSignal;
	}
	
	@Override
	public void run() {
		try {
			startSignal.await();
			doWork();
			doneSignal.countDown();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	void doWork() {
		System.out.println("doWork()");
	}
}

        场景二：把一个大问题分成N个部分，每一个部分对应一个线程放到线程池中执行，当每一个线程执行完成完毕后发出做完信号，既调用doneSignal.countDown()方法；当所有线程都执行完毕后，主流程才能继续往下执行。

package ThreadStudy;

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

public class Driver2 {
	public static void main(String[] args) throws Exception {
		int N = 5;
		CountDownLatch doneSignal = new CountDownLatch(N);
		//定义线程池
		ExecutorService exec = Executors.newSingleThreadExecutor();
		for (int i = 0; i < N; i++) {
			exec.execute(new Work2(doneSignal, i));
		}
		//等待所有线程执行完成
		doneSignal.await();
		System.out.println("doSomethingElse()");
		//关闭线程池
		exec.shutdown();
	}
}

class Work2 implements Runnable {
	private CountDownLatch doneSignal;
	private int i;

	public Work2(CountDownLatch doneSignal, int i) {
		this.doneSignal = doneSignal;
		this.i = i;
	}

	@Override
	public void run() {
		doWork(i);
		doneSignal.countDown();
	}

	void doWork(int i) {
		System.out.println("doWork():" + i);
	}
}

三、CountDownLatch与CyclicBarrier对比

四、CountDownLatch类中方法使用示例

package ThreadStudy;

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

public class Csdn {
	public static void main(String[] args) throws Exception {
		int countLatch = 3;
		// 创建指定个数的门闩
		CountDownLatch countDownLatch = new CountDownLatch(countLatch);
		System.out.println("toString方法0：" + countDownLatch.toString());
		for (int i = 0; i < countLatch; i++) {
			new Thread(new Runnable() {

				@Override
				public void run() {
					try {
						// 门闩数减一
						Thread.sleep(3000);
						countDownLatch.countDown();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}

				}
			}).start();
		}
		// 获取门闩数量
		long n = countDownLatch.getCount();
		System.out.println("门闩数量：" + n);
		// 指定等待的超时时间
		countDownLatch.await(1, TimeUnit.SECONDS);
		System.out.println("过了超时时间程序继续往下执行");
		// 当前线程等待，直到门闩数是0，程序才往下执行
		countDownLatch.await();
		System.out.println("toString方法1：" + countDownLatch.toString());

	}
}

五、CyclicBarrier类中方法使用示例

package ThreadStudy;

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

public class CyclicBarrierTest {
	public static void main(String[] args) {

		// 构造方法一：创建一个线程为3的循环障碍点，3个线程都到达障碍点后，才往下走！
		 CyclicBarrier cb1 = new CyclicBarrier(3);

		// 构造方法二：创建一个新的CyclicBarrier,当最后一个线程通过障碍点后会触发此处的线程执行
		CyclicBarrier cb = new CyclicBarrier(3, new Runnable() {

			@Override
			public void run() {
				System.out.println("==通过障碍点后触发执行的线程==");
			}
		});
		// 返回当前在屏障处等待的人数。此方法主要用于调试和断言
		int a = cb.getNumberWaiting();
		System.out.println("返回当前在屏障处等待的人数" + a);

		// 返回跨越该障碍所需的人数
		int b = cb.getParties();
		System.out.println("返回跨越该障碍所需的人数:" + b);

		// 查询此屏障是否处于中断状态：
		boolean bo = cb.isBroken();
		System.out.println("查询此屏障是否处于中断状态：" + bo);

		for (int i = 0; i < 4; i++) {

			new Thread(new Runnable() {

				@Override
				public void run() {

					System.out.println("线程：" + Thread.currentThread().getName() + "进入障碍点等待");
					try {
						// 等待，直到所有各方都调用了这个屏障上的await。
						int d = cb.await();
						System.out.println("d:" + d);

						// 等待，直到所有各方都调用了此屏障上的await，或指定的等待时间过去
						int c = cb.await(1, TimeUnit.SECONDS);
						System.out.println("c:" + c);
					} catch (Exception e) {
						e.printStackTrace();
					}
					System.out.println("通过障碍点");

				}
			}).start();
		}
		// 复位操作,此时在障碍点等待的线程会抛出BrokenBarrierException异常
		cb.reset();
	}
}