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： 所有线程互相等待完成。