倒计时锁在Java多线程中是如何使用的？

Question

有人能帮我理解什么是JavaCountDownLatch以及什么时候使用它吗？

我不太清楚这个程序是如何工作的。据我所知，所有三个线程都同时启动，每个线程在3000ms后都会调用CountDownLatch。所以倒计时会一个接一个地递减。闩锁变为零后，程序会打印“已完成”。也许我理解的方式不正确。

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class Processor implements Runnable {
    private CountDownLatch latch;

    public Processor(CountDownLatch latch) {
        this.latch = latch;
    }

    public void run() {
        System.out.println("Started.");

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        latch.countDown();
    }
}

// -----------------------------------------------------

public class App {

    public static void main(String[] args) {

        CountDownLatch latch = new CountDownLatch(3); // coundown from 3 to 0

        ExecutorService executor = Executors.newFixedThreadPool(3); // 3 Threads in pool

        for(int i=0; i < 3; i++) {
            executor.submit(new Processor(latch)); // ref to latch. each time call new Processes latch will count down by 1
        }

        try {
            latch.await();  // wait until latch counted down to 0
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Completed.");
    }

}

Answer 1

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



     }
  }

Answer 2

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

CountDownLatch根据锁存原理工作，线程将等待门打开。一个线程等待n创建CountDownLatch时指定的线程数。

例如最终CountDownLatch闩锁=new CountDownLatch（3）；

这里我们把计数器设为3。

任何线程，通常是应用程序的主线程，调用countdownlock。wait（）将等待计数达到零或被另一个线程中断。所有其他线程都需要通过调用CountDownLatch进行倒计时。工作完成后，他们就可以开始倒计时了。当计数达到零时，线程等待开始运行。

这里的计数通过CountDownLatch递减。倒计时（）方法。

调用await（）方法的线程将等待初始计数达到零。

要使计数为零，其他线程需要调用CountDown（）方法。一旦计数为零，调用wait（）方法的线程将恢复（开始执行）。

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

Answer 3

是的，你没理解错。CountDownLatch在闩锁原理下工作，主线程将等到门打开。一个线程等待n个线程，在创建CountDownLatch时指定。

任何线程，通常是应用程序的主线程，调用CountDownLatch.await（）都会等待，直到计数达到零或者被另一个线程中断。所有其他线程都需要在完成或准备好后通过调用CountDownLatch.countDown（）进行倒计时。

一旦计数达到零，等待线程就会继续。CountDownLatch的缺点/优点之一是它不能重用：一旦计数达到零，您就不能再使用CountDownLatch。

编辑：

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

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

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