同步辅助类 java.util.concurrent.CountDownLatch

一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

用给定的计数初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用 CyclicBarrier。

CountDownLatch(int count)

构造一个用给定计数初始化的 CountDownLatch。

await()

使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断。

await(long timeout, TimeUnit unit)

使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断或超出了指定的等待时间。

countDown()

递减锁存器的计数，如果计数到达零，则释放所有等待的线程。

示例一：

import java.util.concurrent.CountDownLatch;

public class Driver {
	public static void main(String[] args) throws InterruptedException {
		CountDownLatch startSignal = new CountDownLatch(1);
		CountDownLatch doneSignal = new CountDownLatch(100);

		for (int i = 0; i < 100; ++i) {
			new Thread(new Worker(startSignal, doneSignal)).start();
		}

		System.out.println("准备工作已做好，可以开始工作了...");
		startSignal.countDown();
		doneSignal.await();
		System.out.println("所有工作完成了");
	}
}

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

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

	public void run() {
		try {
			startSignal.await();
			doWork();
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		} finally {
			doneSignal.countDown();
		}
	}

	void doWork() {
		System.out.println(Thread.currentThread().getName() + " 正在工作");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

示例二：

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

class Driver2 {
	public static void main(String[] args) throws InterruptedException {
		CountDownLatch doneSignal = new CountDownLatch(100);
		ThreadPoolExecutor executor = new ThreadPoolExecutor(100, 110, 1, TimeUnit.SECONDS,
				new LinkedBlockingQueue<>(100));

		for (int i = 0; i < 100; i++) {
			executor.execute(new WorkerRunnable(doneSignal, i));
		}
		
		doneSignal.await();
		System.out.println("所有工作完成");
		executor.shutdown();

	}
}

class WorkerRunnable implements Runnable {
	private final CountDownLatch doneSignal;
	private final int i;

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

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

	void doWork(int i) {
		System.out.println(Thread.currentThread().getName() + " 正在工作-" + i);
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

同步辅助类 java.util.concurrent.CountDownLatch

猜你喜欢