最好的选择是CyclicBarrier，如https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CountDownLatch.html 看到的:

CountDownLatch使用给定的计数进行初始化。由于调用了countDown()方法，await方法阻塞直到当前计数为零，在此之后所有等待的线程都被释放，并且await的任何后续调用立即返回。这是一个一次性现象——计数不能重置。如果您需要一个重置计数的版本，请考虑使用CyclicBarrier。

是的，你理解对了。 CountDownLatch的工作原理是闩锁，主线程将等待门被打开。一个线程等待n个线程，这是在创建CountDownLatch时指定的。

任何调用CountDownLatch.await()的线程(通常是应用程序的主线程)都将等待，直到count达到零或被另一个线程中断。所有其他线程都需要在完成或准备就绪后调用CountDownLatch.countDown()进行倒计时。

只要count达到0，等待线程就会继续。CountDownLatch的一个缺点/优点是它不可重用:一旦count达到0，就不能再使用CountDownLatch了。

编辑:

当一个线程(如主线程)需要等待一个或多个线程完成后才能继续处理时，使用CountDownLatch。

在Java中使用CountDownLatch的一个经典示例是一个服务器端核心Java应用程序，该应用程序使用服务体系结构，其中多个服务由多个线程提供，在所有服务成功启动之前应用程序不能开始处理。

注: OP的问题有一个非常简单的例子，所以我没有包括一个。

package practice;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch c= new CountDownLatch(3);  // need to decrements the count (3) to zero by calling countDown() method so that main thread will wake up after calling await() method 
        Task t = new Task(c);
        Task t1 = new Task(c);
        Task t2 = new Task(c);
        t.start();
        t1.start();
        t2.start();
        c.await(); // when count becomes zero main thread will wake up 
        System.out.println("This will print after count down latch count become zero");
    }
}

class Task extends Thread{
    CountDownLatch c;

    public Task(CountDownLatch c) {
        this.c = c;
    }

    @Override
    public void run() {
        try {
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(1000);
            c.countDown();   // each thread decrement the count by one 
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

NikolaB解释得很好，但是举例有助于理解，所以这里有一个简单的例子…

 import java.util.concurrent.*;


  public class CountDownLatchExample {

  public static class ProcessThread implements Runnable {

    CountDownLatch latch;
    long workDuration;
    String name;

    public ProcessThread(String name, CountDownLatch latch, long duration){
        this.name= name;
        this.latch = latch;
        this.workDuration = duration;
    }


    public void run() {
        try {
            System.out.println(name +" Processing Something for "+ workDuration/1000 + " Seconds");
            Thread.sleep(workDuration);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name+ "completed its works");
        //when task finished.. count down the latch count...

        // basically this is same as calling lock object notify(), and object here is latch
        latch.countDown();
    }
}


public static void main(String[] args) {
    // Parent thread creating a latch object
    CountDownLatch latch = new CountDownLatch(3);

    new Thread(new ProcessThread("Worker1",latch, 2000)).start(); // time in millis.. 2 secs
    new Thread(new ProcessThread("Worker2",latch, 6000)).start();//6 secs
    new Thread(new ProcessThread("Worker3",latch, 4000)).start();//4 secs


    System.out.println("waiting for Children processes to complete....");
    try {
        //current thread will get notified if all chidren's are done 
        // and thread will resume from wait() mode.
        latch.await();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    System.out.println("All Process Completed....");

    System.out.println("Parent Thread Resuming work....");



     }
  }

来自oracle关于CountDownLatch的文档:

一种同步辅助工具，允许一个或多个线程等待在其他线程中执行的一组操作完成。

CountDownLatch使用给定的计数进行初始化。由于调用了countDown()方法，await方法阻塞直到当前计数为零，在此之后所有等待的线程都被释放，并且await的任何后续调用立即返回。这是一个一次性现象——计数不能重置。

CountDownLatch是一种通用的同步工具，可用于许多目的。

初始化为1的CountDownLatch用作简单的开/关锁存器或门:所有调用await的线程都在门处等待，直到由调用countDown()的线程打开。

初始化为N的CountDownLatch可用于使一个线程等待到N个线程完成某个操作，或者某个操作已完成N次。

public void await()
           throws InterruptedException

导致当前线程等待，直到锁存器计数到零，除非线程被中断。

如果当前计数为零，则此方法立即返回。

public void countDown()

减少锁存器的计数，如果计数为零，则释放所有等待线程。

如果当前计数大于零，则递减。如果新的计数为零，则所有等待的线程都将重新启用以进行线程调度。

解释你的例子。

You have set count as 3 for latch variable CountDownLatch latch = new CountDownLatch(3); You have passed this shared latch to Worker thread : Processor Three Runnable instances of Processor have been submitted to ExecutorService executor Main thread ( App ) is waiting for count to become zero with below statement latch.await(); Processor thread sleeps for 3 seconds and then it decrements count value with latch.countDown() First Process instance will change latch count as 2 after it's completion due to latch.countDown(). Second Process instance will change latch count as 1 after it's completion due to latch.countDown(). Third Process instance will change latch count as 0 after it's completion due to latch.countDown(). Zero count on latch causes main thread App to come out from await App program prints this output now : Completed

最好的选择是CyclicBarrier，如https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CountDownLatch.html 看到的:

CountDownLatch使用给定的计数进行初始化。由于调用了countDown()方法，await方法阻塞直到当前计数为零，在此之后所有等待的线程都被释放，并且await的任何后续调用立即返回。这是一个一次性现象——计数不能重置。如果您需要一个重置计数的版本，请考虑使用CyclicBarrier。