JDK1.8源码阅读与翻译:CountDownLatch

/*
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

package java.util.concurrent;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;

/**
 * A synchronization aid that allows one or more threads to wait until
 * a set of operations being performed in other threads completes.
 * CountDownLatch是一个同步辅助类,允许一个或多个线程等待,直到其他线程
 * 进行的一系列操作完成。
 *
 * 

A {@code CountDownLatch} is initialized with a given count. * 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。达到0后所有阻塞的线程都会释放并且await的 * 后续调用会立即执行。这个过程是一次性的--count值不能重新设置。如果您需 * 要count可以重设的版本,可以考虑使用CyclicBarrier。 * *

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 N * can be used to make one thread wait until N threads have * completed some action, or some action has been completed N times. * CountDownLatch是一个多功能的同步工具可以被用于多种目的。一个用count=1 * 初始化的CountDownLatch可以用作简单的开关或门禁:所有调用await()的线程 * 都在门禁处等待,直到一个其他线程通过countDown()打开门禁。一个用count=N * 初始化的CountDownLatch可以用于让一个线程等待,直到N个其他线程完成某些 * 动作,或某些动作被完成N次。 * *

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。它只是阻止任何线程通过await()的阻塞,直到所有线程都可以 * 通过。 * *

Sample usage: Here is a pair of classes in which a group * of worker threads use two countdown latches: *

    *
  • The first is a start signal that prevents any worker from proceeding * until the driver is ready for them to proceed; *
  • The second is a completion signal that allows the driver to wait * until all workers have completed. *
* 示例:这里有两个类,一组工作线程使用两个CountDownLatch: * 第一个CountDownLatch是一个开始信号,避免任何工人在司机准备好之前就进行工作。 * 第二个CountDownLatch是一个完成信号,允许司机等待所有工人工作完成。 * *
 {@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() { ... }
 * }}
* *

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来 * 执行并进行countDown(),所有的Runnable放入Executor。当所有的部分都完成时, * 线程才可以通过await()。(当线程必须重复countDown时,用CyclicBarrier来代替) * *

 {@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() { ... }
 * }}
* *

Memory consistency effects: Until the count reaches * zero, actions in a thread prior to calling * {@code countDown()} * happen-before * actions following a successful return from a corresponding * {@code await()} in another thread. * 内存一致效果:直到count减到0,之前调用了countDown()的线程的动作,happen-before * 调用await()的线程成功返回后的动作。(这里的含义个人理解是countDown会比await先返回, * 因为AQS中的state是被volatile修饰的,java的“先行发生”原则保证了countDown对state的 * 更新操作先于await中对state的读操作) * * @since 1.5 * @author Doug Lea */ public class CountDownLatch { /** * Synchronization control For CountDownLatch. * Uses AQS state to represent count. * CountDownLatch的同步控制。 * 使用AQS(AbstractQueuedSynchronizer)的状态(state)来表示count。 */ private static final class Sync extends AbstractQueuedSynchronizer { private static final long serialVersionUID = 4982264981922014374L; Sync(int count) { setState(count); } int getCount() { return getState(); } protected int tryAcquireShared(int acquires) { // 尝试获取共享锁,当state(就是count)为0时,返回1成功,否则-1失败 // 获取锁失败时,AQS内会LockSupport.park(),当前线程进入阻塞(waiting)。 return (getState() == 0) ? 1 : -1; } protected boolean tryReleaseShared(int releases) { // Decrement count; signal when transition to zero // count减一,当减到0时发出信号,其实就是返回true时AQS会将阻塞线程全部unPark for (;;) { int c = getState(); if (c == 0) return false; int nextc = c-1; if (compareAndSetState(c, nextc)) return nextc == 0; } } } private final Sync sync; /** * 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 */ 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}. * 调用本方法将使当前线程进入等待状态,直到锁计数器减为0,除非这个线程被 * 中断(interrupted)。 * *

If the current count is zero then this method returns immediately. * 如果当前的count就是0,,本函数将立即返回。 * *

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: * 如果当前count大于0,则当前线程因线程调度进入休眠,直到以下两种情况发生: * *

    *
  • The count reaches zero due to invocations of the * {@link #countDown} method; or *
  • Some other thread {@linkplain Thread#interrupt interrupts} * the current thread. *
* count由于countDown被调用减到0;或其他线程将当前线程中断。 * *

If the current thread: *

    *
  • has its interrupted status set on entry to this method; or *
  • is {@linkplain Thread#interrupt interrupted} while waiting, *
* then {@link InterruptedException} is thrown and the current thread's * interrupted status is cleared. * 如果当前线程: * 进入本方法前就设置了中断状态,或在waiting时调用中断函数Thread.interrupt(), * 则本函数将抛出InterruptedException,并清理掉当前线程的interrupted状态。 * * @throws InterruptedException if the current thread is interrupted * while waiting */
public void await() throws InterruptedException { sync.acquireSharedInterruptibly(1); } /** * Causes the current thread to wait until the latch has counted down to * zero, unless the thread is {@linkplain Thread#interrupt interrupted}, * or the specified waiting time elapses. * 调用本方法将使当前线程进入等待状态,直到锁计数器减为0,除非这个线程被 * 中断(interrupted),或者超出了指定的等待时间。 * *

If the current count is zero then this method returns immediately * with the value {@code true}. * *

If the current count is greater than zero then the current * thread becomes disabled for thread scheduling purposes and lies * dormant until one of three things happen: *

    *
  • The count reaches zero due to invocations of the * {@link #countDown} method; or *
  • Some other thread {@linkplain Thread#interrupt interrupts} * the current thread; or *
  • The specified waiting time elapses. *
* *

If the count reaches zero then the method returns with the * value {@code true}. * *

If the current thread: *

    *
  • has its interrupted status set on entry to this method; or *
  • is {@linkplain Thread#interrupt interrupted} while waiting, *
* then {@link InterruptedException} is thrown and the current thread's * interrupted status is cleared. * *

If the specified waiting time elapses then the value {@code false} * is returned. If the time is less than or equal to zero, the method * will not wait at all. * 如果超出了指定的等待时长,将会返回false。如果指定时长不大于0,本方法 * 将不会进入等待。 * * @param timeout the maximum time to wait * @param unit the time unit of the {@code timeout} argument * @return {@code true} if the count reached zero and {@code false} * if the waiting time elapsed before the count reached zero * @throws InterruptedException if the current thread is interrupted * while waiting */ public boolean await(long timeout, TimeUnit unit) throws InterruptedException { return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout)); } /** * Decrements the count of the latch, releasing all waiting threads if * the count reaches zero. * 将锁计数器count递减,当减到0时释放所有的等待线程。 * *

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,则所有的等待线程将 * 重新启用以进行线程调度。 * *

If the current count equals zero then nothing happens. * 如果当前count为0,本函数不会触发任何操作。 */ public void countDown() { sync.releaseShared(1); } /** * Returns the current count. * 返回当前的count值。 * *

This method is typically used for debugging and testing purposes. * 本函数通常用于调试和测试。 * * @return the current count */ public long getCount() { return sync.getCount(); } /** * Returns a string identifying this latch, as well as its state. * The state, in brackets, includes the String {@code "Count ="} * followed by the current count. * * @return a string identifying this latch, as well as its state */ public String toString() { return super.toString() + "[Count = " + sync.getCount() + "]"; } }

你可能感兴趣的:(源码分析)