Класс CountDownLatch

CountDownLatch инициализируется заданным значением count. Методы await блокируют выполнение, пока текущее значение count не станет нулём в результате вызовов метода countDown(), после чего все ожидающие потоки освобождаются, и последующие вызовы await возвращают значение немедленно. Это однократное явление — значение count не может быть сброшено. Если вам нужна версия, которая сбрасывает значение count, используйте класс CyclicBarrier.

CountDownLatch — это универсальный инструмент синхронизации, который может использоваться для различных целей. CountDownLatch, инициализированный значением count равным единице, служит простым счётчиком или воротами: все потоки, вызывающие await, ожидают у ворот, пока они не откроются потоком, вызывающим countDown(). CountDownLatch, инициализированный значением N, может использоваться для ожидания одним потоком, пока N потоков завершат некоторое действие, или пока это действие было выполнено N раз.

Полезное свойство CountDownLatch заключается в том, что потоки, вызывающие countDown, не требуют ожидания, пока count достигнет нуля, прежде чем продолжить. Они просто препятствуют любому потоку перейти за пределы 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() { ... }
 }

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