Класс 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 в очередь Executor. Когда все подзадачи будут завершены, координирующий поток сможет продолжить выполнение после вызова 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() в другом потоке.