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

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

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

编辑:

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

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

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

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....");



     }
  }

CountDownLatch在Java中是一种同步器，它允许一个线程在开始处理之前等待一个或多个线程。

CountDownLatch工作在闩锁原理，线程将等待直到门打开。在创建CountDownLatch时，一个线程等待指定的n个线程。

例如:final CountDownLatch = new CountDownLatch(3);

这里我们将计数器设置为3。

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

这里的计数是通过CountDownLatch.countDown()方法递减的。

调用await()方法的线程将一直等待，直到初始计数为零。

为了使计数为零，其他线程需要调用countDown()方法。 一旦计数为零，调用await()方法的线程将恢复(开始执行)。

CountDownLatch的缺点是它不可重用:一旦计数为零，它就不再可用。

CoundDownLatch使您能够让一个线程等待所有其他线程执行完毕。

伪代码可以是:

// Main thread starts
// Create CountDownLatch for N threads
// Create and start N threads
// Main thread waits on latch
// N threads completes there tasks are returns
// Main thread resume execution

One good example of when to use something like this is with Java Simple Serial Connector, accessing serial ports. Typically you'll write something to the port, and asyncronously, on another thread, the device will respond on a SerialPortEventListener. Typically, you'll want to pause after writing to the port to wait for the response. Handling the thread locks for this scenario manually is extremely tricky, but using Countdownlatch is easy. Before you go thinking you can do it another way, be careful about race conditions you never thought of!!

伪代码:

CountDownLatch latch;
void writeData() { 
   latch = new CountDownLatch(1);
   serialPort.writeBytes(sb.toString().getBytes())
   try {
      latch.await(4, TimeUnit.SECONDS);
    } catch (InterruptedException e) {
   }
}
class SerialPortReader implements SerialPortEventListener {
    public void serialEvent(SerialPortEvent event) {
        if(event.isRXCHAR()){//If data is available
            byte buffer[] = serialPort.readBytes(event.getEventValue());
            latch.countDown();
         }
     }
}

当我们想要等待多个线程完成其任务时，就会使用它。它类似于线程连接。

我们可以在哪里使用CountDownLatch

考虑这样一个场景:我们有三个线程“a”、“B”和“C”，我们希望只有在“a”和“B”线程完成或部分完成它们的任务时才启动线程“C”。

它可以应用于真实的It场景

考虑这样一个场景，经理将模块划分到开发团队(a和B)之间，他希望仅在两个团队都完成任务时将模块分配给QA团队进行测试。

public class Manager {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(2);
        MyDevTeam teamDevA = new MyDevTeam(countDownLatch, "devA");
        MyDevTeam teamDevB = new MyDevTeam(countDownLatch, "devB");
        teamDevA.start();
        teamDevB.start();
        countDownLatch.await();
        MyQATeam qa = new MyQATeam();
        qa.start();
    }   
}

class MyDevTeam extends Thread {   
    CountDownLatch countDownLatch;
    public MyDevTeam (CountDownLatch countDownLatch, String name) {
        super(name);
        this.countDownLatch = countDownLatch;       
    }   
    @Override
    public void run() {
        System.out.println("Task assigned to development team " + Thread.currentThread().getName());
        try {
                Thread.sleep(2000);
        } catch (InterruptedException ex) {
                ex.printStackTrace();
        }
        System.out.println("Task finished by development team " + Thread.currentThread().getName());
        this.countDownLatch.countDown();
    }
}

class MyQATeam extends Thread {   
    @Override
    public void run() {
        System.out.println("Task assigned to QA team");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        System.out.println("Task finished by QA team");
    }
}

以上代码的输出为:

分配给开发团队devB的任务

分配给开发团队devA的任务

任务由开发团队devB完成

由开发团队devA完成的任务

分配给QA团队的任务

QA团队完成的任务

这里await()方法等待countdownlatch标志变为0，而countDown()方法将countdownlatch标志减1。

JOIN的限制: 上面的例子也可以通过JOIN实现，但是JOIN不能在两种情况下使用:

当我们使用ExecutorService而不是Thread类创建线程时。 修改上面的例子，经理希望在开发完成80%的任务后立即将代码移交给QA团队。这意味着CountDownLatch允许我们修改实现，可以用来等待另一个线程的部分执行。

如果你在调用latch.countDown()后添加一些调试，这可能会帮助你更好地理解它的行为。

latch.countDown();
System.out.println("DONE "+this.latch); // Add this debug

输出将显示Count正在递减。这个“计数”实际上是你启动的可运行任务(处理器对象)的数量，其中countDown()没有被调用，因此在主线程调用latch.await()时被阻塞。

DONE java.util.concurrent.CountDownLatch@70e69696[Count = 2]
DONE java.util.concurrent.CountDownLatch@70e69696[Count = 1]
DONE java.util.concurrent.CountDownLatch@70e69696[Count = 0]

来自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

As mentioned in JavaDoc (https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CountDownLatch.html), CountDownLatch is a synchronization aid, introduced in Java 5. Here the synchronization does not mean restricting access to a critical section. But rather sequencing actions of different threads. The type of synchronization achieved through CountDownLatch is similar to that of Join. Assume that there is a thread "M" which needs to wait for other worker threads "T1", "T2", "T3" to complete its tasks Prior to Java 1.5, the way this can be done is, M running the following code

    T1.join();
    T2.join();
    T3.join();

上面的代码确保线程M在T1、T2、T3完成它的工作之后恢复它的工作。T1, T2, T3可以按任意顺序完成它们的工作。 同样可以通过CountDownLatch实现，其中T1、T2、T3和线程M共享相同的CountDownLatch对象。 "M"请求:countDownLatch.await(); 其中“T1”，“T2”，“T3”是countDownLatch.countdown();

连接方法的一个缺点是M必须知道T1、T2、T3。如果后来添加了一个新的工作线程T4，那么M也必须知道它。使用CountDownLatch可以避免这种情况。 实现后的动作顺序为[T1,T2,T3](T1,T2,T3的顺序可以任意)-> [M]

在此链接中解释了countDownLatch的最佳实时示例

这个来自Java Doc的例子帮助我清楚地理解了这些概念:

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

视觉解释:

显然，CountDownLatch允许一个线程(这里是Driver)等待一堆正在运行的线程(这里是Worker)完成它们的执行。

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();
        }
    }
}

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

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