原文地址：http://blog.csdn.net/lmj623565791/article/details/26626391 

每天起早貪黑的上班，父母每天也要上班，話說今天定了個飯店，一家人一起吃個飯，通知大家下班去飯店集合。假設：3個人在不同的地方上班，必須等到3個人到場才能吃飯，用程式如何實現呢？

public class Test1  
{  
    /** 
     * 模擬爸爸去飯店 
     */  
    public static void fatherToRes()  
    {  
        System.out.println("爸爸步行去飯店需要3小時。");  
    }  

    /** 
     * 模擬媽媽去飯店 
     */  
    public static void motherToRes()  
    {  
        System.out.println("媽媽擠公交去飯店需要2小時。");  
    }  

    /** 
     * 模擬我去飯店 
     */  
    public static void meToRes()  
    {  
        System.out.println("我乘地鐵去飯店需要1小時。");  
    }  

    /** 
     * 模擬一家人到齊了 
     */  
    public static void togetherToEat()  
    {  
        System.out.println("一家人到齊了，開始吃飯");  
    }  

    public static void main(String[] args)  
    {  
        fatherToRes();  
        motherToRes();  
        meToRes();  
        togetherToEat();  
    }  
}  
 

輸出結果：

爸爸步行去飯店需要3小時。  
媽媽擠公交去飯店需要2小時。  
我乘地鐵去飯店需要1小時。  
一家人到齊了，開始吃飯  

看似實現了，但是吃個飯，光匯合花了6個小時，第一個到的等了3個小時；話說回來，大家下班同時往飯店聚集，怎麼也是個並行的過程，於是不用我說，大家肯定都行想到使用多執行緒，於是作為一名資深屌絲程式猿，開始改造我們的程式碼：

public static void main(String[] args)  
    {  
        new Thread()  
        {  
            public void run()  
            {  
                fatherToRes();  
            };  
        }.start();  
        new Thread()  
        {  
            public void run()  
            {  
                motherToRes();  
            };  
        }.start();  
        new Thread()  
        {  
            public void run()  
            {  
                meToRes();  
            };  
        }.start();  

        togetherToEat();  
    }  
 

直接啟動了3個執行緒，但是執行結果貌似也不對：

一家人到齊了，開始吃飯  
我乘地鐵去飯店需要1小時。  
媽媽擠公交去飯店需要2小時。  
爸爸步行去飯店需要3小時。 

一個都沒到，就開始吃飯了，，，（為了更好的顯示，我在每個方法中休息了一段時間，模擬到達飯店的過程）。還是不行，那就繼續完善：

private static volatile int i = 3;  

    public static void main(String[] args)  
    {  

        new Thread()  
        {  
            public void run()  
            {  
                fatherToRes();  
                i--;  
            };  
        }.start();  
        new Thread()  
        {  
            public void run()  
            {  
                motherToRes();  
                i--;  
            };  
        }.start();  
        new Thread()  
        {  
            public void run()  
            {  
                meToRes();  
                i--;  
            };  
        }.start();  

        while (i != 0);  
        togetherToEat();  
    }  
 

我們定義了一個volatile修飾的int型別變數，初始值為3，當為0時代表一家人齊了，於是我們在主執行緒使用了一個忙等，一直等待所有人到達，這次效果看起來不錯哦：

我乘地鐵去飯店需要1小時。  
媽媽擠公交去飯店需要2小時。  
爸爸步行去飯店需要3小時。  
一家人到齊了，開始吃飯  

但是，忙等這樣的程式碼對於CPU的消耗太巨大了，我們需要更好的實現方式。順便說一下volatile，為什麼我們用volatile修飾 i 呢， 因為當多個執行緒操作同一個變數時，為了保證變數修改對於其他執行緒的可見性，必須使用同步，volatile對於可見性的實現是個不錯的選擇，但是我們程式碼中的 i – 也有可能因為併發造成一定的問題，畢竟i–不是原子操作，正常最好使用同步塊或者AtomicLong.decrementAndGet()實現–。 
說了這麼多，標題上的CountLatchDown竟然沒出現，所以最終版，必須讓這哥們出來亮相了：

private static CountDownLatch latch = new CountDownLatch(3);  

    public static void main(String[] args) throws InterruptedException  
    {  

        new Thread()  
        {  
            public void run()  
            {  
                fatherToRes();  
                latch.countDown();  
            };  
        }.start();  
        new Thread()  
        {  
            public void run()  
            {  
                motherToRes();  
                latch.countDown();  
            };  
        }.start();  
        new Thread()  
        {  
            public void run()  
            {  
                meToRes();  
                latch.countDown();  
            };  
        }.start();  

        latch.await();  
        togetherToEat();  
    }  

輸出結果：

我乘地鐵去飯店需要1小時。  
媽媽擠公交去飯店需要2小時。  
爸爸步行去飯店需要3小時。  
一家人到齊了，開始吃飯  

避免使用忙等，我們使用了CountDowmLatch 實現了我們的需求。下面具體介紹一下這個哥們： 
Latch閉鎖的意思，是一種同步的工具類。類似於一扇門：在閉鎖到達結束狀態之前，這扇門一直是關閉著的，不允許任何執行緒通過，當到達結束狀態時，這扇門會開啟並允許所有的執行緒通過。且當門打開了，就永遠保持開啟狀態。 
作用：可以用來確保某些活動直到其他活動都完成後才繼續執行。 
使用場景： 
1、例如我們上例中所有人都到達飯店然後吃飯； 
2、某個操作需要的資源初始化完畢 
3、某個服務依賴的執行緒全部開啟等等… 
CountDowmLatch是一種靈活的閉鎖實現，包含一個計數器，該計算器初始化為一個正數，表示需要等待事件的數量。countDown方法遞減計數器，表示有一個事件發生，而await方法等待計數器到達0，表示所有需要等待的事情都已經完成。