用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法,所以在当前计数到达零之前,await 方法会一直受阻塞。之后,会释放所有等待的线程,await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数,请考虑使用 CyclicBarrier。
CountDownLatch 是一个通用同步工具,它有很多用途。将计数 1 初始化的 CountDownLatch 用作一个简单的开/关锁存器,或入口:在通过调用 countDown() 的线程打开入口前,所有调用 await 的线程都一直在入口处等待。用 N 初始化的 CountDownLatch 可以使一个线程在 N 个线程完成某项操作之前一直等待,或者使其在某项操作完成 N 次之前一直等待。
CountDownLatch 的一个有用特性是,它不要求调用 countDown 方法的线程等到计数到达零时才继续,而在所有线程都能通过之前,它只是阻止任何线程继续通过一个 await。
示例用法: 下面给出了两个类,其中一组 worker 线程使用了两个倒计数锁存器:
第一个类是一个启动信号,在 driver 为继续执行 worker 做好准备之前,它会阻止所有的 worker 继续执行。
第二个类是一个完成信号,它允许 driver 在完成所有 worker 之前一直等待。
class Driver { // ...
void main() throws InterruptedException {
CountDownLatch startSignal = new CountDownLatch(1);
CountDownLatch doneSignal = new CountDownLatch(N);
for (int i = 0; i < N; ++i) // create and start threads
new Thread(new Worker(startSignal, doneSignal)).start();
doSomethingElse(); // don't let run yet
startSignal.countDown(); // let all threads proceed
doSomethingElse();
doneSignal.await(); // wait for all to finish
}
}
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();
doneSignal.countDown();
} catch (InterruptedException ex) {} // return;
}
void doWork() { ... }
}
另一种典型用法是,将一个问题分成 N 个部分,用执行每个部分并让锁存器倒计数的 Runnable 来描述每个部分,然后将所有 Runnable 加入到 Executor 队列。当所有的子部分完成后,协调线程就能够通过 await。(当线程必须用这种方法反复倒计数时,可改为使用 CyclicBarrier。)
class Driver2 { // ...
void main() throws InterruptedException {
CountDownLatch doneSignal = new CountDownLatch(N);
Executor e = ...
for (int i = 0; i < N; ++i) // create and start threads
e.execute(new WorkerRunnable(doneSignal, i));
doneSignal.await(); // wait for all to finish
}
}
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() {
try {
doWork(i);
doneSignal.countDown();
} catch (InterruptedException ex) {} // return;
}
void doWork() { ... }
}
public class WaitAllSubThread {
/*int liveThreadNum;//记录运行的子线程数
*/
int n; //工作线程数
public WaitAllSubThread(int n) {
this.n = n;
}
class Worker implements Runnable {
String name;
int sleep;
public Worker(String name, int sleep) {
this.name = name;
this.sleep = sleep;
}
public void run() {
/*upLive(); //计算此线程已经工作.
*/
System.out.println(name+", start to work.");
try {
Thread.sleep(sleep); //虚拟工作. 10s 随机时间
} catch (InterruptedException e) {
System.out.println(name+" interrupted.");
}
System.out.println(name+", end to work ["+sleep+"] sleep.");
/*downLive(); //此线程工作完成
*/
}
}
/* //记录线程数的同步方法.
private synchronized void downLive() {
liveThreadNum--;
}
private synchronized void upLive() {
liveThreadNum++;
}
private synchronized boolean isLive() {
return liveThreadNum > 0;
}*/
public void run() {
System.out.println("-------------main run start-------------");
int sleepSaid = 10 * 1000; //每个工作线程虚拟工作最大时间
Random rm = new Random();
for(int i=0; i<ths.length; i++) {
ths[i] = new Thread(new MyTask(rm.nextInt(sleep)+1));
ths[i].start();
}
for(Thread th : ths) {
try {
th.join();//join方式
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/*//等待所有工作线程完成.
while(isLive()) {
try {
Thread.sleep(1000); //每隔1s查看下是否所有线程完成.
} catch (InterruptedException e) {
System.out.println("main thread sleep interrupted.");
}
}*/
System.out.println("---------------main run end--------------");
}
public static void main(String[] args) {
WaitAllSubThread wast = new WaitAllSubThread(10);
wast.run();
}
}
public class CountDownLatchUse {
final CountDownLatch downLatch;
int n; //工作线程数
public CountDownLatchUse(int n) {
this.downLatch = new CountDownLatch(n);
this.n = n;
}
class Worker implements Runnable {
String name;
int sleep;
public Worker(String name, int sleep) {
this.name = name;
this.sleep = sleep;
}
public void run() {
System.out.println(name+", start to work.");
try {
Thread.sleep(sleep); //虚拟工作. 10s 随机时间
} catch (InterruptedException e) {
System.out.println(name+" interrupted.");
}
System.out.println(name+", end to work ["+sleep+"] sleep.");
meDone(); //某个工作线程完成
}
}
private void meDone() {
downLatch.countDown();
}
public void run() {
System.out.println("-------------main run start-------------");
int sleepSaid = 10 * 1000; //每个工作线程虚拟工作最大时间
Random rm = new Random();
for(int i=0; i<n; i++) {
new Thread(new Worker("worker-"+i, rm.nextInt(sleepSaid)+1)).start();
}
try {
downLatch.await(); //等待所有工作线程完成.
} catch (InterruptedException e) {
System.out.println("main interrupted.");
}
System.out.println("---------------main run end--------------");
}
public static void main(String[] args) {
CountDownLatchUse mtu = new CountDownLatchUse(10);
mtu.run();
}
}