1、CountDownLatch，主要用于将一个任务分为n个独立的部分，等这些部分都完成后继续接下来的任务，CountDownLatch 只能出发一次，计数值不能被重置。一个或者是一部分线程 ，等待另外一部线程都完成了，再继续执行

例子：

Module：一个工程中各子模块的任务执行

1. public class Module implements Runnable { 
2.     private CountDownLatch countDownLatch; 
3.     private String         moduleName; 
4.     private int            time; 
5.  
6.     /** 
7.      * @param countDownLatch 
8.      * @param moduleName 
9.      * @param time 
10.      */ 
11.     public Module(CountDownLatch countDownLatch, String moduleName, int time) { 
12.         super(); 
13.         this.countDownLatch = countDownLatch; 
14.         this.moduleName = moduleName; 
15.         this.time = time; 
16.     } 
17.  
18.     /* 
19.      * (non-Javadoc) 
20.      * @see java.lang.Runnable#run() 
21.      */ 
22.     public void run() { 
23.         work(); 
24.         countDownLatch.countDown(); 
25.     } 
26.  
27.     /** 
28.      *  
29.      */ 
30.     private void work() { 
31.         try { 
32.             TimeUnit.MILLISECONDS.sleep(time); 
33.             System.out.println(moduleName + " 耗时: " + time + "ms."); 
34.         } catch (InterruptedException e) { 
35.             e.printStackTrace(); 
36.         } 
37.  
38.     } 
39.  
40. } 

在整个工程来看，所有的子模块完成之后才能叫完成。处于多模块完结的下游任务。

1. public class Controller implements Runnable { 
2.     private CountDownLatch countDownLatch; 
3.  
4.     /** 
5.      * @param countDownLatch 
6.      */ 
7.     public Controller(CountDownLatch countDownLatch) { 
8.         super(); 
9.         this.countDownLatch = countDownLatch; 
10.     } 
11.  
12.     /* 
13.      * (non-Javadoc) 
14.      * @see java.lang.Runnable#run() 
15.      */ 
16.     public void run() { 
17.         try { 
18.             countDownLatch.await(); 
19.             System.out.println("所有模块完成，任务完成"); 
20.         } catch (InterruptedException e) { 
21.             e.printStackTrace(); 
22.         } 
23.     } 
24.  
25. } 

测试：

1. private static final int SIZE = 20; 
2.  
3.    public static void main(String[] args) { 
4.        CountDownLatch countDownLatch = new CountDownLatch(SIZE); 
5.        Random random = new Random(); 
6.        ExecutorService executorService = Executors.newCachedThreadPool(); 
7.        Controller controller = new Controller(countDownLatch); 
8.        executorService.execute(controller); 
9.        for (int i = 0; i < SIZE; i++) { 
10.            executorService.execute(new Module(countDownLatch, "模块：" + i, random.nextInt(2000))); 
11.        } 
12.        executorService.shutdown(); 
13.  
14.    } 

测试结果：

1. 模块：6 耗时: 14ms. 
2. 模块：13 耗时: 203ms. 
3. 模块：17 耗时: 339ms. 
4. 模块：14 耗时: 544ms. 
5. 模块：3 耗时: 577ms. 
6. 模块：8 耗时: 580ms. 
7. 模块：0 耗时: 695ms. 
8. 模块：12 耗时: 985ms. 
9. 模块：4 耗时: 1142ms. 
10. 模块：16 耗时: 1228ms. 
11. 模块：2 耗时: 1260ms. 
12. 模块：15 耗时: 1304ms. 
13. 模块：11 耗时: 1486ms. 
14. 模块：19 耗时: 1495ms. 
15. 模块：5 耗时: 1497ms. 
16. 模块：18 耗时: 1540ms. 
17. 模块：7 耗时: 1613ms. 
18. 模块：10 耗时: 1649ms. 
19. 模块：1 耗时: 1697ms. 
20. 模块：9 耗时: 1872ms. 
21. 所有模块完成，任务完成 

2、CyclicBarrier： 所有线程互相等待完成。 

 本文转自 tianya23 51CTO博客，原文链接：http://blog.51cto.com/tianya23/790019，如需转载请自行联系原作者