CountDownLatch源碼及JavaDoc閱覽
/**
* 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);
}
...
}
