開篇

相信小伙伴對這個兩個詞或多或少都有些了解，他們是在并發編程中常用的線程通訊工具。兩者十分相似，但是又有不同，導致很多小伙伴也包括我在內產生了很多困惑：他們兩個究竟有什么區別，以及適用于什么場景呢?

[[330337]]

下面聽我緩緩道來，不想看例子或者過程的小伙伴可以拉到最下面看總結呦

閉鎖

閉鎖(CountDownLatch)坊間俗稱計數器，官方(谷歌機翻，哈哈)解釋：

/** 
 * A synchronization aid that allows one or more threads to wait until 
 * a set of operations being performed in other threads completes. 
 */ 
 
允許一個或多個線程等待，直到在其他線程中執行的一組操作完成的同步輔助程序。 

大概意思就是說，可以有一個或者多個線程，等待其他線程都完成某個操作后，再繼續執行。

什么意思呢?舉個栗子吧：

生活中應該經常遇見一種情況，坐公交車是，尤其是始發站，司機師傅往往為了一次拉更多的乘客，會等到車上乘客的數量到達一定程度以后才會發車。測試代碼如下：

public static void main(String[] args) { 
        List<Passenger> list = new ArrayList<>(); 
        Passenger p1 = new Passenger("看會書"); 
        Passenger p2 = new Passenger("看會手機"); 
        Passenger p3 = new Passenger("看會風景"); 
        Passenger p4 = new Passenger("看會售票員"); 
        list.add(p1); 
        list.add(p2); 
        list.add(p3); 
        list.add(p4); 
        ThreadPoolExecutor executor = new ThreadPoolExecutor(20, 200, 1000, TimeUnit.SECONDS, new LinkedBlockingQueue<>(3), new ThreadFactory() { 
            private ThreadGroup group = (null == System.getSecurityManager() ? Thread.currentThread().getThreadGroup() : System.getSecurityManager().getThreadGroup()); 
            private AtomicInteger num = new AtomicInteger(); 
            @Override 
            public Thread newThread(Runnable r) { 
                Thread thread = new Thread(group, r,"zoo" + num.getAndIncrement(),0); 
                thread.setDaemon(false); 
                return thread; 
            } 
        }, new ThreadPoolExecutor.CallerRunsPolicy()); 
        //設定閉鎖釋放閾值 
        CountDownLatch countDownLatch = new CountDownLatch(list.size()); 
        log.error("司機師傅人夠一車再發車，等會人吧..."); 
        for (Passenger p : list) { 
            executor.execute(()->gotoZOO(p,countDownLatch)); 
        } 
        try { 
            countDownLatch.await(); 
            log.error("人夠了，起飛！"); 
            executor.shutdown(); 
        } catch (InterruptedException e) { 
            e.printStackTrace(); 
        } 
 
    } 
 
    private static void  gotoZOO(Passenger p,CountDownLatch countDownLatch){ 
        log.error("{}的乘客上車啦",p.getDoWhat()); 
        try { 
            countDownLatch.countDown(); 
            log.error("{}",p.doWhatOnBus()); 
        } catch (Exception e) { 
            e.printStackTrace(); 
        } 
    } 
 
    static class Passenger{ 
        private String doWhat; 
 
        public Passenger(String doWhat) { 
            this.doWhat = doWhat; 
        } 
 
        public String getDoWhat() { 
            return doWhat; 
        } 
 
        public String doWhatOnBus() { 
            return "車上好無聊啊，"+doWhat+"吧！"; 
        } 
    } 

執行結果

23:46:34.698 [main] ERROR com.test - 司機師傅人夠一車再發車，等會人吧... 
23:46:34.757 [zoo1] ERROR com.test - 看會手機的乘客上車啦 
23:46:34.758 [zoo3] ERROR com.test - 看會售票員的乘客上車啦 
23:46:34.757 [zoo0] ERROR com.test - 看會書的乘客上車啦 
23:46:34.759 [zoo1] ERROR com.test - 車上好無聊啊，看會手機吧！ 
23:46:34.759 [zoo3] ERROR com.test - 車上好無聊啊，看會售票員吧！ 
23:46:34.757 [zoo2] ERROR com.test - 看會風景的乘客上車啦 
23:46:34.759 [zoo0] ERROR com.test - 車上好無聊啊，看會書吧！ 
23:46:34.759 [zoo2] ERROR com.test - 車上好無聊啊，看會風景吧！ 
23:46:34.759 [main] ERROR com.test - 人夠了，起飛！ 

司機師傅(主線程)要等上了4個乘客以后才發車(等待4個子線程完成完成某件事以后調用countDown方法)，而乘客上車(調用countDown)以后該做自己的事還做自己的事情，不會因為上了車就傻呆呆的什么都不干了(不會因為調用了countDown而阻塞自身)。等司機師傅看人夠了(到達設定閾值)，就發車了。

閉鎖總結：

• 主線程調用await后會阻塞等待其他子線程調用countDown方法將設定閾值減至0，然后在繼續執行。
• 而子線程不會因為調用了countDown方法而阻塞

柵欄

柵欄(CyclicBarrier)官方解釋：

/** 
 * A synchronization aid that allows a set of threads to all wait for 
 * each other to reach a common barrier point.  CyclicBarriers are 
 * useful in programs involving a fixed sized party of threads that 
 * must occasionally wait for each other. The barrier is called 
 * <em>cyclic</em> because it can be re-used after the waiting threads 
 * are released. 
 */ 
同步幫助，允許一組線程互相等待，以達到共同的障礙點。 CyclicBarriers在涉及固定大小的線程方的程序中很有用，這些線程有時必須互相等待。該屏障稱為<em> cyclic </ em>，因為它可以在釋放等待線程后重新使用。 

從類注釋上我們可以大致了解到，他是運用在一組，也即是多個線程中的，當所有線程到達某個狀態前一直阻塞，直到所有線程都達到后再繼續執行。而且是可以重復使用的。

上面的描述還是太晦澀了，還是舉個栗子：

我們小時候學校都組織過春游，規定好地點，等人到齊了就一起進去玩。寫了個簡單的例子，看這種場景柵欄是怎么工作的

public static void main(String[] args) { 
        List<Boy> list = new ArrayList<>(); 
        Boy boy1 = new Boy("看老虎"); 
        Boy boy2 = new Boy("看猩猩"); 
        Boy boy3 = new Boy("看獅子"); 
        Boy boy4 = new Boy("看售票員"); 
        list.add(boy1); 
        list.add(boy2); 
        list.add(boy3); 
        list.add(boy4); 
        ThreadPoolExecutor executor = new ThreadPoolExecutor(20, 200, 1000, TimeUnit.SECONDS, new LinkedBlockingQueue<>(3), new ThreadFactory() { 
            private ThreadGroup group = (null == System.getSecurityManager() ? Thread.currentThread().getThreadGroup() : System.getSecurityManager().getThreadGroup()); 
            private AtomicInteger num = new AtomicInteger(); 
            @Override 
            public Thread newThread(Runnable r) { 
                Thread thread = new Thread(group, r,"zoo" + num.getAndIncrement(),0); 
                thread.setDaemon(false); 
                return thread; 
            } 
        }, new ThreadPoolExecutor.CallerRunsPolicy()); 
        //初始化柵欄，設置障礙點閾值 
        CyclicBarrier cyclicBarrier = new CyclicBarrier(list.size()); 
        for (Boy boy : list) { 
            executor.execute(()->gotoZOO(boy,cyclicBarrier)); 
        } 
    } 
 
    private static void  gotoZOO(Boy boy,CyclicBarrier cyclicBarrier){ 
        log.error("人還沒到齊呢，等一下吧,{}的小男孩開始等待",boy.getWhere()); 
        try { 
            cyclicBarrier.await(); 
            log.error("{}",boy.goWhere()); 
        } catch (Exception e) { 
            e.printStackTrace(); 
        } 
    } 
 
    static class Boy{ 
        private String where; 
        public Boy(String where) { 
            this.where = where; 
        } 
 
        public String getWhere() { 
            return where; 
        } 
 
        public String goWhere() { 
            return "人到齊了，我要去"+where+"啦！"; 
        } 
    } 

執行結果：

22:05:59.476 [zoo2] ERROR com.test - 人還沒到齊呢，等一下吧,看獅子的小男孩開始等待 
22:05:59.477 [zoo1] ERROR com.test - 人還沒到齊呢，等一下吧,看猩猩的小男孩開始等待 
22:05:59.477 [zoo0] ERROR com.test - 人還沒到齊呢，等一下吧,看老虎的小男孩開始等待 
22:05:59.476 [zoo3] ERROR com.test - 人還沒到齊呢，等一下吧,看售票員的小男孩開始等待 
22:05:59.484 [zoo0] ERROR com.test - 人到齊了，我要去看老虎啦！ 
22:05:59.484 [zoo2] ERROR com.test - 人到齊了，我要去看獅子啦！ 
22:05:59.484 [zoo3] ERROR com.test - 人到齊了，我要去看售票員啦！ 
22:05:59.484 [zoo1] ERROR com.test - 人到齊了，我要去看猩猩啦！ 

我們可以發現前三個小男孩在到達以后都沒有進到動物園里，而是直到第四個小男孩來到以后，四個小男孩才進入動物園，在此之前每來一個小朋友就多一個小朋友等待(每個線程調用await方法)，直到等待所有人到齊(線程阻塞等待達到柵欄障礙點4)，各個小男孩再去繼續進入動物園看動物(各線程繼續執行自己的任務)。就像是動物園大門的柵欄，買的是團體票，每次必須人到齊才放開讓小朋友進去一樣。

柵欄總結

各子線程相互等待，直到達到柵欄初始化時的閾值，則繼續執行

區分以及個人理解

閉鎖：有點類似于一個統計功能(可能這也是為什么他俗稱計數器)，主線程調用await方法阻塞等待統計結果，而子線程只負責在達到統計要求時調用countDown方法告訴主線程我好了，而不會阻塞本身;有一個負責接收結果(主線程)和一個或多個發送數量的(子線程);

柵欄：首先在線程調用await方法時會阻塞當前線程，其次個人理解他沒有類似像閉鎖那樣的主子的關系，他是各個線程相互等待，都到達某個點的時候，則繼續執行。

適用場景

其實從上面的區分就能看出一些：如果是需要將多線程執行完成與否的接口匯總到某一個線程中，然后再繼續執行的情況，比如每條線程計算一個指標，都計算完成以后再計算所有指標的總和或者其他的，就可以使用閉鎖;

而如果只是各個線程需要等各個線程都完成了，再繼續自己的事，可以使用柵欄，比如ABC三個線程分別去獲取123三個指標，然后再A要取這三個數的平均數，B要取總和，C要取方差，那就需要等ABC都先取完了123這三個指標，才能計算，這時候就可以用到柵欄了。

總結

這兩種都是非常好的線程通訊工具，不過細節還是有所差異。

總得來說就是：

• 閉鎖是為了在某一條線程等待獲取到其他線程的執行結果;
• 而柵欄則是線程間的相互等待，然后再同時開始做各自的事情

最后

文中的代碼只是為了比較好的說明兩種工具的差異，寫的不好還請小伙伴們多多包涵，如果發現有哪點寫的不對的也歡迎大家伙們留言，我們共同進步!最后如果小伙伴覺得文章不錯，不妨動動小手點個贊再走，不要下次一定呦~