閉鎖和柵欄的區分以及適用場景
開篇
相信小伙伴對這個兩個詞或多或少都有些了解，他們是在并發編程中常用的線程通訊工具。兩者十分相似，但是又有不同，導致很多小伙伴也包括我在內產生了很多困惑：他們兩個究竟有什么區別，以及適用于什么場景呢?
下面聽我緩緩道來，不想看例子或者過程的小伙伴可以拉到最下面看總結呦
閉鎖
閉鎖(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這三個指標，才能計算，這時候就可以用到柵欄了。
總結
這兩種都是非常好的線程通訊工具，不過細節還是有所差異。
總得來說就是：
- 閉鎖是為了在某一條線程等待獲取到其他線程的執行結果;
- 而柵欄則是線程間的相互等待，然后再同時開始做各自的事情
最后
文中的代碼只是為了比較好的說明兩種工具的差異，寫的不好還請小伙伴們多多包涵，如果發現有哪點寫的不對的也歡迎大家伙們留言，我們共同進步!最后如果小伙伴覺得文章不錯，不妨動動小手點個贊再走，不要下次一定呦~
