Java中的 CountDownLatch工具类

最近在公司项目中遇到 CountDownLatch 工具类，特意查了查相关的资料，特做此记录，有些内容为网络摘取。

CountDownLatch 简介：

CountDownLatch 是一个同步工具类，在Java 1.5中被引入，用来协调多个线程之间的同步，位于 java.util.cucurrent 包下。

CountDownLatch 的原理：

CountDownLatch 能够使一个线程（假如线程A）在等待另外一些线程（假如线程B、C、D）完成各自工作之后，再继续执行。其原理是使用一个计数器实现的：计数器初始值为线程的数量，在CountDownLatch类初始化的时候指定。当线程B、C、D中的任何一个完成自己任务后，计数器的值就会减一。当计数器的值为0时，表示所有的线程（B、C、D）都已经完成一些任务，然后在CountDownLatch上等待的线程（线程A）就可以继续执行接下来的任务。

CountDownLatch 使用步骤：

（1）在主线程中初始化CountDownLatch 工具类，初始化时，指定计数器的初始值：

CountDownLatch latch = new CountDownLatch(3);

（2）创建A、B、C、D 四个线程，将 latch对象作为参数传入；

（3）在线程A中，对latch对象执行 await() 方法，等待B、C、D执行完毕再执行；

（4）分别在B、C、D中执行各自的业务逻辑，业务逻辑执行完毕后，各自对latch对象执行 countDown()方法，将计数器的值减去1；（与第（3）步骤可以互调顺序）

（5）在计数器的值为0时（即B、C、D都执行完毕后），线程A开始执行。

具体的例子（网络摘取，很形象）：

有三个工人在为老板干活，这个老板有一个习惯，就是当三个工人把一天的活都干完了的时候，他就来检查所有工人所干的活。记住这个条件：三个工人先全部干完活，老板才检查。

所以在这里用Java代码设计两个类，Worker代表工人，Boss代表老板，具体的代码实现如下：

Worker.java

package org.zapldy.concurrent;  
  
import java.util.Random;  
import java.util.concurrent.CountDownLatch;  
import java.util.concurrent.TimeUnit;  
  
public class Worker implements Runnable{  
      
    private CountDownLatch downLatch;  
    private String name;  
      
    public Worker(CountDownLatch downLatch, String name){  
        this.downLatch = downLatch;  
        this.name = name;  
    }  
      
    public void run() {  
        this.doWork();  
        try{  
            TimeUnit.SECONDS.sleep(new Random().nextInt(10));  
        }catch(InterruptedException ie){  
        }  
        System.out.println(this.name + "活干完了！");  
        this.downLatch.countDown();  
          
    }  
      
    private void doWork(){  
        System.out.println(this.name + "正在干活!");  
    }  
      
}  

Boss.java

package org.zapldy.concurrent;  
  
import java.util.concurrent.CountDownLatch;  
  
public class Boss implements Runnable {  
  
    private CountDownLatch downLatch;  
      
    public Boss(CountDownLatch downLatch){  
        this.downLatch = downLatch;  
    }  
      
    public void run() {  
        System.out.println("老板正在等所有的工人干完活......");  
        try {  
            this.downLatch.await();  
        } catch (InterruptedException e) {  
        }  
        System.out.println("工人活都干完了，老板开始检查了！");  
    }  
  
}  

CountDownLatchDemo.java 测试类

package org.zapldy.concurrent;  
  
import java.util.concurrent.CountDownLatch;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
  
public class CountDownLatchDemo {  
  
    public static void main(String[] args) {  
        ExecutorService executor = Executors.newCachedThreadPool();  
          
        CountDownLatch latch = new CountDownLatch(3);  
          
        Worker w1 = new Worker(latch,"张三");  
        Worker w2 = new Worker(latch,"李四");  
        Worker w3 = new Worker(latch,"王二");  
          
        Boss boss = new Boss(latch);  
          
        executor.execute(w3);  
        executor.execute(w2);  
        executor.execute(w1);  
        executor.execute(boss);  
          
        executor.shutdown();  
    }  
  
}  

当你运行CountDownLatchDemo这个对象的时候，你会发现是等所有的工人都干完了活，老板才来检查，下面是我本地机器上运行的一次结果，可以肯定的每次运行的结果可能与下面不一样，但老板检查永远是在后面的。

执行结果：

王二正在干活!  
李四正在干活!  
老板正在等所有的工人干完活......  
张三正在干活!  
张三活干完了！  
王二活干完了！  
李四活干完了！  
工人活都干完了，老板开始检查了！