CountDownLatch用法

      Java的concurrent包里面的CountDownLatch其实可以把它看作一个计数器，只不过这个计数器的操作是原子操作，同时只能有一个线程去操作这个计数器，也就是同时只能有一个线程去减这个计数器里面的值。

　　　　CountDownLatch的计数器只能使用一次

      你可以向CountDownLatch对象设置一个初始的数字作为计数值，任何调用这个对象上的await()方法都会阻塞，直到这个计数器的计数值被其他的线程减为0为止。

      CountDownLatch的一个非常典型的应用场景是：有一个任务想要往下执行，但必须要等到其他的任务执行完毕后才可以继续往下执行。假如我们这个想要继续往下执行的任务调用一个CountDownLatch对象的await()方法，其他的任务执行完自己的任务后调用同一个CountDownLatch对象上的countDown()方法，这个调用await()方法的任务将一直阻塞等待，直到这个CountDownLatch对象的计数值减到0为止。

      举个例子，有三个工人在为老板干活，这个老板有一个习惯，就是当三个工人把一天的活都干完了的时候，他就来检查所有工人所干的活。记住这个条件：三个工人先全部干完活，老板才检查。所以在这里用Java代码设计两个类，Worker代表工人，Boss代表老板，具体的代码实现如下：

1.package org.zapldy.concurrent;  
2.  
3.import java.util.Random;  
4.import java.util.concurrent.CountDownLatch;  
5.import java.util.concurrent.TimeUnit;  
6.  
7.public class Worker implements Runnable{  
8.      
9.    private CountDownLatch downLatch;  
10.    private String name;  
11.      
12.    public Worker(CountDownLatch downLatch, String name){  
13.        this.downLatch = downLatch;  
14.        this.name = name;  
15.    }  
16.      
17.    public void run() {  
18.        this.doWork();  
19.        try{  
20.            TimeUnit.SECONDS.sleep(new Random().nextInt(10));  
21.        }catch(InterruptedException ie){  
22.        }  
23.        System.out.println(this.name + "活干完了！");  
24.        this.downLatch.countDown();  
25.          
26.    }  
27.      
28.    private void doWork(){  
29.        System.out.println(this.name + "正在干活!");  
30.    }  
31.      
32.}  

java

1.package org.zapldy.concurrent;  
2.  
3.import java.util.concurrent.CountDownLatch;  
4.  
5.public class Boss implements Runnable {  
6.  
7.    private CountDownLatch downLatch;  
8.      
9.    public Boss(CountDownLatch downLatch){  
10.        this.downLatch = downLatch;  
11.    }  
12.      
13.    public void run() {  
14.        System.out.println("老板正在等所有的工人干完活......");  
15.        try {  
16.            this.downLatch.await();  
17.        } catch (InterruptedException e) {  
18.        }  
19.        System.out.println("工人活都干完了，老板开始检查了！");  
20.    }  
21.  
22.}  

java

1.package org.zapldy.concurrent;  
2.  
3.import java.util.concurrent.CountDownLatch;  
4.import java.util.concurrent.ExecutorService;  
5.import java.util.concurrent.Executors;  
6.  
7.public class CountDownLatchDemo {  
8.  
9.    public static void main(String[] args) {  
10.        ExecutorService executor = Executors.newCachedThreadPool();  
11.          
12.        CountDownLatch latch = new CountDownLatch(3);  
13.          
14.        Worker w1 = new Worker(latch,"张三");  
15.        Worker w2 = new Worker(latch,"李四");  
16.        Worker w3 = new Worker(latch,"王二");  
17.          
18.        Boss boss = new Boss(latch);  
19.          
20.        executor.execute(w3);  
21.        executor.execute(w2);  
22.        executor.execute(w1);  
23.        executor.execute(boss);  
24.          
25.        executor.shutdown();  
26.    }  
27.  
28.}  

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

打印结果：

1.王二正在干活!  
2.李四正在干活!  
3.老板正在等所有的工人干完活......  
4.张三正在干活!  
5.张三活干完了！  
6.王二活干完了！  
7.李四活干完了！  
8.工人活都干完了，老板开始检查了！  

转载：https://zapldy.iteye.com/blog/746458

　　问题：：：：

执行countdown的某个子线程可能会因为某些原因无法执行countdown，这样就会导致await线程一直阻塞下去。

在线程池中多次调用await方法，因为await方法会阻塞一段时间，有可能导致线程池可用线程被大量阻塞。

 　　解决办法是最好不要用CountDownLatch实例的await()，归避长时间阻塞线程的风险，任何多线程应用程序都有死锁风险，改用CountDownLatch实例的await(long timeout, TimeUnit unit)，设定超时时间