閉鎖 CountDownLatch

假設：3我的在不一樣的地方上班，必須等到3我的到場才能吃飯，用程序如何實現呢？ 做爲一名資深屌絲程序猿，開始寫代碼實現：

package com.zhy.concurrency.latch;  
  
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閉鎖的意思，是一種同步的工具類。相似於一扇門：在閉鎖到達結束狀態以前，這扇門一直是關閉着的，不容許任何線程經過，當到達結束狀態時，這扇門會打開並容許全部的線程經過。且當門打開了，就永遠保持打開狀態。 做用：能夠用來確保某些活動直到其餘活動都完成後才繼續執行。 使用場景： 一、例如咱們上例中全部人都到達飯店而後吃飯； 二、某個操做須要的資源初始化完畢 三、某個服務依賴的線程所有開啓等等... CountDowmLatch是一種靈活的閉鎖實現，包含一個計數器，該計算器初始化爲一個正數，表示須要等待事件的數量。countDown方法遞減計數器，表示有一個事件發生，而await方法等待計數器到達0，表示全部須要等待的事情都已經完成。

注意：countDown方法最好放在finally代碼塊中執行。