有人能帮助我理解什么是Java CountDownLatch以及什么时候使用它吗?
我不太清楚这个项目是怎么运作的。据我所知，这三个线程同时开始，每个线程将在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.");
}
}
如果你在调用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]
如果你在调用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]
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的工作原理是闩锁，主线程将等待门被打开。一个线程等待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....");
}
}
