/**
* A synchronization aid that allows one or more threads to wait until
* a set of operations being performed in other threads completes.
* 一种允许一个或多个线程处于等待状态直到其他线程完成一系列操作的同步机制。
* <p>A {@code CountDownLatch} is initialized with a given <em>count</em>.
* The {@link #await await} methods block until the current count reaches
* zero due to invocations of the {@link #countDown} method, after which
* all waiting threads are released and any subsequent invocations of
* {@link #await await} return immediately. This is a one-shot phenomenon
* -- the count cannot be reset. If you need a version that resets the
* count, consider using a {@link CyclicBarrier}.
* CountDownLatch通过给定的数值count初始化。await方法将处于阻塞状态直到countDown方法被调用时当前count值达到0为止，
在这之后所有处于waiting线程都被释放并且后续调用await方法都会立即返回。CountDownLatch的count是一次性的，即不能被重置。如果你需要一个可重置的count，考虑使用CyclicBarrier。
* <p>A {@code CountDownLatch} is a versatile synchronization tool
* and can be used for a number of purposes. A
* {@code CountDownLatch} initialized with a count of one serves as a
* simple on/off latch, or gate: all threads invoking {@link #await await}
* wait at the gate until it is opened by a thread invoking {@link
* #countDown}. A {@code CountDownLatch} initialized to <em>N</em>
* can be used to make one thread wait until <em>N</em> threads have
* completed some action, or some action has been completed N times.
* CountDownLatch是一种通用的、有多种用途的同步工具。一个用“1”初始化的CountDownLatch相当于一个简单的开关门，
所有执行了await方法就像在一扇关闭的门前等待，直到某个线程执行了countDown方法将该门打开。
* <p>A useful property of a {@code CountDownLatch} is that it
* doesn't require that threads calling {@code countDown} wait for
* the count to reach zero before proceeding, it simply prevents any
* thread from proceeding past an {@link #await await} until all
* threads could pass.
* CountDownLatch的一个有用特性是，它不要求调用countDown的线程等待count达到0才继续执行。在所有线程能pass之前，它只是简单的通过await方法阻止任何线程继续（此句翻译不太准确）。
* <p><b>Sample usage:</b> Here is a pair of classes in which a group
* of worker threads use two countdown latches:
* <ul>
* <li>The first is a start signal that prevents any worker from proceeding
* until the driver is ready for them to proceed;
* <li>The second is a completion signal that allows the driver to wait
* until all workers have completed.
* </ul>
* 示例用法:这里有两个类，其中worker类使用两个CountDownLatch：
第一个是启动信号，在driver准备好让worker继续之前它会阻止任何worker继续工作。
第二个是完成信号，在所有workers完成之前driver都会处于等待状态。
* <pre> {@code
* 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() { ... }
* }}</pre>
*
* <p>Another typical usage would be to divide a problem into N parts,
* describe each part with a Runnable that executes that portion and
* counts down on the latch, and queue all the Runnables to an
* Executor. When all sub-parts are complete, the coordinating thread
* will be able to pass through await. (When threads must repeatedly
* count down in this way, instead use a {@link CyclicBarrier}.)
* 另一种典型的用法是将一个问题分成N个部分，用一个Runnable来描述每个部分，该Runnable执行该部分并在锁存器上计数，然后将所有Runnables排队给一个执行器.
当所有子部件完成后，协调线程将能够通过wait(不会处于等待状态）。(当线程必须以这种方式重复计数时，使用CyclicBarrier。)
* <pre> {@code
* 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() { ... }
* }}</pre>
*
* <p>Memory consistency effects: Until the count reaches
* zero, actions in a thread prior to calling
* {@code countDown()}
* <a href="package-summary.html#MemoryVisibility"><i>happen-before</i></a>
* actions following a successful return from a corresponding
* {@code await()} in another thread.
* 内存一致性效应:在count为0之前，一个线程调用countDown()方法之前的动作 happen-before 从另一个线程相应的await()方法返回之后的动作（可参见JSR-133规范）
* @since 1.5
* @author Doug Lea
*/
public class CountDownLatch {
/**
* Constructs a {@code CountDownLatch} initialized with the given count.
*
* @param count the number of times {@link #countDown} must be invoked
*
before threads can pass through {@link #await}
* @throws IllegalArgumentException if {@code count} is negative
* 参数count，在线程能通过await之前countDown方法必须被执行的次数
*/
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
/**
* Causes the current thread to wait until the latch has counted down to
* zero, unless the thread is {@linkplain Thread#interrupt interrupted}.
* 除非当前线程被中断，否则将导致当前线程处于wait状态直到latch减到0。
*
* <p>If the current count is zero then this method returns immediately.
* 如果当前count为0，此方法会立即返回。
* <p>If the current count is greater than zero then the current
* thread becomes disabled for thread scheduling purposes and lies
* dormant until one of two things happen:
* <ul>
* 如果当前count大于0，出于线程调度的目的，当前线程处于禁用休眠状态，直到发生以下两种情况之一：
* <li>The count reaches zero due to invocations of the
* {@link #countDown} method; or
* <li>Some other thread {@linkplain Thread#interrupt interrupts}
* the current thread.
* </ul>
* 执行 countDown方法后count达到0；或者
* 其他线程interrupt当前线程
* <p>If the current thread:
* <ul>
* <li>has its interrupted status set on entry to this method; or
* <li>is {@linkplain Thread#interrupt interrupted} while waiting,
* </ul>
* then {@link InterruptedException} is thrown and the current thread's
* interrupted status is cleared.
* 如果当前线程在进入此方法时设置了其interrupted状态；或
* 在waiting时被interrupt，将抛出InterrupedException并且当前线程的interrupted状态将被清除。
* @throws InterruptedException if the current thread is interrupted
*
while waiting
*/
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
/**
* Decrements the count of the latch, releasing all waiting threads if
* the count reaches zero.
* 递减latch的count值，如果count达到0则释放所有处于waiting线程。
* <p>If the current count is greater than zero then it is decremented.
* If the new count is zero then all waiting threads are re-enabled for
* thread scheduling purposes.
* 如果当前count大于0，则执行递减操作。如果递减后的count值为0，
* 则所有处于waiting状态的线程被重新启用以便线程调度。
* <p>If the current count equals zero then nothing happens.
* 如果当前count为0则什么都不操作。
*/
public void countDown() {
sync.releaseShared(1);
}
...
}