compact1, compact2, compact3

java.util.concurrent

Class CountDownLatch

java.lang.Object

java.util.concurrent.CountDownLatch

public class CountDownLatch
extends Object

一种同步帮助，允许一个或多个线程等待，直到在其他线程中执行的一组操作完成。

一个CountDownLatch与给定数初始化。的await方法块直到当前计数达到零的countDown()方法调用，之后，所有等待的线程，释放任何后续的调用await立即返回。这是一一个镜头的现象-计数不能被重置。如果你需要一个版本，重置计数，考虑使用CyclicBarrier。

一个CountDownLatch是一种通用的同步工具，可以用于许多用途。一个CountDownLatch初始化计算的一个作为一个简单的开/关锁，门：所有线程调用await在门口等候直到它被一个线程调用countDown()打开。一个CountDownLatch初始化n可以用来使一个线程等待直到n个线程完成一些动作，或一些行动已经完成N次。

一个CountDownLatch是一个有用的特性，它不需要线程countDown等待计数达到零之前，它只是防止任何线程进行过await直到所有的线程可以通过。

示例用法：这里是对类的一组线程使用两倒计时锁：

• 第一个是一个开始信号，防止任何工人进行，直到司机准备他们继续进行；
• 第二个是一个完成信号，允许司机等待，直到所有的工人已经完成。

 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对象给执行者。当所有的子部件都完成后，协调线程将能够通过等待。（当线程必须反复倒在这条路上，而不是使用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() { ... }
 }

内存一致性效果：直到计数达到零，在调用countDown() happen-before行动从另一个线程中的相应的await()成功返回前一个线程的行为。

从以下版本开始：

一点五

构造方法摘要

构造方法

Constructor and Description
CountDownLatch(int count) 构建了一个 CountDownLatch与给定的计数初始化。

方法摘要

Modifier and Type	Method and Description
void	await() 使当前线程等待直到锁向下计数为零，除非线程 interrupted。
boolean	await(long timeout, TimeUnit unit) 使当前线程等待直到锁向下计数为零，除非线程 interrupted，或指定的等待时间的流逝。
void	countDown() 减少锁的数量，释放所有等待的线程，如果计数为零。
long	getCount() 返回当前计数。
String	toString() 返回一个识别该锁存器的字符串，以及它的状态。

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

CountDownLatch

public CountDownLatch(int count)

构建了一个 CountDownLatch与给定的计数初始化。

参数

count -次 countDown()数必须调用之前调用的线程可以通过 await()

异常

IllegalArgumentException -如果 count是负的

方法详细信息

await

public void await()
           throws InterruptedException

使当前线程等待直到锁向下计数为零，除非线程 interrupted。

如果当前的计数为零，则此方法将立即返回。

如果当前的计数大于零，那么当前的线程将被禁用的线程调度的目的，并处于休眠状态，直到两个事情发生：

• 计数达到零的countDown()方法调用；或
• 其他某个线程interrupts当前线程。

如果当前线程：

• 在该方法的入口上有它的中断状态；或
• 是interrupted等待，

然后 InterruptedException投入和当前线程的中断状态被清除。

异常

InterruptedException -如果当前线程中断等待

await

public boolean await(long timeout,
                     TimeUnit unit)
              throws InterruptedException

使当前线程等待直到锁向下计数为零，除非线程 interrupted，或指定的等待时间的流逝。

如果当前计数为零，那么这个方法立即返回的值true。

如果当前的计数大于零，那么当前的线程将被禁用的线程调度的目的，并处于休眠状态，直到三个事情发生：

• 计数达到零的countDown()方法调用；或
• 其他某个线程interrupts当前线程；或
• 指定的等待时间的流逝。

如果计数达到零则该方法返回的值true。

如果当前线程：

• 在该方法的入口上有它的中断状态；或
• 是interrupted等待，

然后 InterruptedException投入和当前线程的中断状态被清除。

如果指定的等待时间的流逝，然后false返回值。如果时间小于或等于零，该方法将不会等待在所有。

参数

timeout -最大等待时间

unit的 timeout争论的时间单位

结果

true如果计数达到零， false如果等待的时间才达到零计数

异常

InterruptedException -如果当前线程中断等待

countDown

public void countDown()

减少锁的数量，释放所有等待的线程，如果计数为零。

如果当前计数大于零则递减。如果新的计数为零，那么所有的等待线程都重新启用了线程调度的目的。

如果当前的计数等于零，那么什么都没有发生。

getCount

public long getCount()

返回当前计数。

此方法通常用于调试和测试目的。

结果

当前计数

toString

public String toString()

返回一个识别该锁存器的字符串，以及它的状态。括号内的状态，包括字符串 "Count ="后跟当前计数。

重写：

toString 方法重写，继承类 Object

结果

识别该锁存器的字符串，以及它的状态