Класс CountDownLatch

Объект 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, который выполняет соответствующую часть и уменьшает значение счётчика, а затем передать все объекты Runnable исполнителю. Когда все подзадачи будут завершены, координирующий поток сможет продолжить выполнение после вызова 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() {
    doWork();
    doneSignal.countDown();
  }

  void doWork() { ... }
}

Эффекты согласованности памяти: пока счётчик не достигнет нуля, действия в потоке, предшествующие вызову countDown(), происходят до действий, следующих за успешным возвратом из соответствующего вызова await() в другом потоке.