CountDownLatch学习

昨天去阿里面试，关于多线程方面的知识问到了CountDownLatch。由于这个类长时间没使用，导致当时没有回答上来，因此今天在此整理一下CountDownLatch相关的笔记，以做学习。

首先，我们看一下jdk关于CountDownLatch这个类的注释：

这是一个同步工具，它允许一个或多个线程在其他线程的任务执行完毕前阻塞。

一个CountDownLatch对象在初始化的时候会指定一个count值。所有的await方法会一直阻塞，直到调用countDown方法使count的值变为0。count的值变为0之后，所有等待中的线程会释放，任何await方法的调用都会立即返回。这是一个一次性的现象——count的值不能重置。如果你需要重置count的值，可以考虑使用CyclicBarrier。

CountDownLatch是一个多功能的同步工具，它能用来实现很多目的。一个CountDownLatch对象可以用来充当一个on/off的门闩，或者闸门：所有执行await方法的线程都会阻塞在这道闸门，直到它被某一个线程调用countDown方法打开。一个初始化为N的CountDownLatch，可以用来使一个线程等待另外的N个线程完成某个任务，或者等待另外的一个线程完成某个任务N次。

CountDownLatch一个有用的特性在于，它不要求调用countDown方法的线程去等待count的值变为0，它仅仅是阻止调用await方法的线程继续执行，直到所有线程可以通过闸门。

案例一：这里有两个类，一组工作线程使用了两个CountDownLatch实例。第一个是一个启动信号，用来防止任何worker在driver准备好之前执行任务。第二个是一个工作完成信号，它允许driver等待所有的worker执行任务结束。

demo如下：

package com.code.countDownLatch;

import java.util.concurrent.CountDownLatch;

public class Driver1 {

	final int N = 10;

	void main() {
		CountDownLatch startSignal = new CountDownLatch(1); // 开始信号
		CountDownLatch doneSignal = new CountDownLatch(N); // 所有任务结束信号
		for (int i = 0; i < N; i++) {
			// 开启N个工作线程
			new Thread(new Worker(startSignal, doneSignal)).start();
		}
		doSomethingElse();
		startSignal.countDown(); // 开始工作线程
		doSomethingElse();
		try {
			doneSignal.await(); // 等待所有的工作线程执行完毕
			System.out.println("all workers finished task");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	private void doSomethingElse() {
		System.out.println(Thread.currentThread().getName() + " doSomethingElse");
	}

	public static void main(String[] args) {
		new Driver1().main();
	}

}

class Worker implements Runnable {
	private final CountDownLatch startSignal;
	private final CountDownLatch doneSignal;

	public Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
		super();
		this.startSignal = startSignal;
		this.doneSignal = doneSignal;
	}

	@Override
	public void run() {
		try {
			startSignal.await(); //等待开始信号
			doWork();
			doneSignal.countDown(); //任务执行完毕，将结束信号doneSignal减一
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	void doWork() {
		System.out.println(Thread.currentThread().getName() + " do work");
	}

}

程序运行结果如下：

main doSomethingElse
main doSomethingElse
Thread-0 do work
Thread-7 do work
Thread-3 do work
Thread-4 do work
Thread-1 do work
Thread-9 do work
Thread-2 do work
Thread-8 do work
Thread-5 do work
Thread-6 do work
all workers finished task

案例二：另一个典型的应用则是，将一个问题分成N个部分，每个部分启动一个线程去执行，执行完毕后CountDown一下门闩，并且所有线程放在一个线程池Executor里面。当所有子线程执行完毕，这个调度线程也就能通过await方法了。

demo如下：

package com.code.countDownLatch;

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

public class Driver2 {
	final int N = 10;

	void main() {
		CountDownLatch doneSignal = new CountDownLatch(N); // 任务完成信号
		ExecutorService  executor = Executors.newFixedThreadPool(N);
		for (int i = 0; i < N; i++) {
			// 开启N个子任务线程
			executor.execute(new Worker2(i, doneSignal));
		}
		try {
			doneSignal.await(); // 等待所有的子任务执行完毕
			System.out.println("the all problem finished");
			executor.shutdown();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) {
		new Driver2().main();
	}
}

class Worker2 implements Runnable {
	private final int part;
	private final CountDownLatch doneSignal;

	public Worker2(int part, CountDownLatch doneSignal) {
		super();
		this.part = part;
		this.doneSignal = doneSignal;
	}

	@Override
	public void run() {
		doWork();
		doneSignal.countDown(); // 任务执行完毕，将结束信号doneSignal减一
	}

	void doWork() {
		System.out.println(Thread.currentThread().getName() + " do work part " + part);
	}

}

程序运行结果如下：

pool-1-thread-5 do work part 4
pool-1-thread-6 do work part 5
pool-1-thread-3 do work part 2
pool-1-thread-2 do work part 1
pool-1-thread-1 do work part 0
pool-1-thread-7 do work part 6
pool-1-thread-4 do work part 3
pool-1-thread-10 do work part 9
pool-1-thread-9 do work part 8
pool-1-thread-8 do work part 7
the all problem finished

注意：CountDownLatch的阻塞方法是await，切莫写成wait。