背景

在編寫業務程式碼時經常遇到併發執行多個任務的需求，因為序列執行太慢，會影響業務程式碼效能。特別對於直接面向普通使用者的業務來說使用者體驗至關重要，保證使用者體驗重要的一點是要“快”。業務程式碼中經常需要呼叫其它業務介面或者同時從多個數據源取資料再處理等，這種情況下勢必要走網路請求，網路消耗必不可少，最好的情況是毫秒級別，一般情況下是幾十毫秒級別，甚至幾百毫秒，TimeoutException恐怕大家並不陌生。

例子

當你瀏覽微信朋友圈時，微信會把你朋友最近的動態展示在你朋友圈裡，並且按照時間順序最近的排在前面。你會發現，朋友圈裡不會展示把你刪除了或者你把他刪除了的好友，不會展示被你設定過“不看他(她)的朋友圈”的好友或者對方把你設定過“不讓他(她)看我的朋友圈”的好友，不會展示被你拉黑或把你拉黑的好友，不會展示被微信系統標記為spam的好友，等等。對於微信這種支援數億人聊天的應用，其系統必定很複雜，解耦做得也比較好。
下面模擬下這個介面的實現：

    public List<Feed> lastestFeeds(String wxId) {
                //序列執行
        //1. 獲取你得好友列表
        //2. 去掉把你刪除的好友
        //3. 去掉被你刪除的好友
        //4. 去掉被你設定過"不看他(她)的朋友圈"的好友
        //5. 去掉對你設定過"不讓他(她)看我的朋友圈"的好友
        //6. 去掉被你拉黑和把你拉黑的好友
        //7. 去掉被微信系統標記為作弊的好友
        //...
                //8. 獲取好友最近動態再返回
 

    }

對於微信這種複雜的系統，通常不可能從一個介面獲取到這些資訊，必須從多個介面獲取到這些資訊後再處理。如果說序列實現這些功能，你可以想象一下是不是慢到吐血，相信微信也不會這麼幹，否則朋友圈會刷半天也沒響應，那麼這個使用者體驗就太糟糕了。那麼這個時候併發執行這些子任務就可以很高效的處理掉這種情況。具體到這個介面也就是會把1-7拆解成單個子任務，再丟到執行緒池非同步的執行。最後執行完了，再彙總處理。

    public List<Feed> lastestFeedsV2(String wxId) {
        //併發執行，無先後先後執行
        //1. 獲取你得好友列表
 

        //2. 去掉把你刪除的好友
        //3. 去掉被你刪除的好友
        //4. 去掉被你設定過"不看他(她)的朋友圈"的好友
        //5. 去掉對你設定過"不讓他(她)看我的朋友圈"的好友
        //6. 去掉被你拉黑和把你拉黑的好友
        //7. 去掉被微信系統標記為作弊的好友
        //...
        //等待所有子任務完成，彙總處理
        //8. 獲取好友最近動態再返回
    }

那麼如何實現併發執行呢，下面討論幾種實現。

CountDownLatch.await() VS ExecutorService.invokeAll()

從功能上講這兩者均可以實現併發執行多個任務並等待的功能。先看程式碼如何完成以上功能：
CountDownLatch實現：

    public List<Feed> lastestFeeds(String wxId) {
        ThreadPoolExecutor executor = ...;
        CountDownLatch latch = new CountDownLatch(7);
        executor.execute(new Runnable() {
            @Override
            public void run() {
                try{
                    //1. 獲取你得好友列表
                } catch (Exception e) {

                } finally {
                    latch.countDown();
                }
            }
        });

        executor.execute(new Runnable() {
            @Override
            public void run() {
                try{
                    //2. 去掉把你刪除的好友
                } catch (Exception e) {

                } finally {
                    latch.countDown();
                }
            }
        });

        executor.execute(new Runnable() {
            @Override
            public void run() {
                try{
                    //3. 去掉被你刪除的好友
                } catch (Exception e) {

                } finally {
                    latch.countDown();
                }
            }
        });

        executor.execute(new Runnable() {
            @Override
            public void run() {
                try{
                    //4. 去掉被你設定過"不看他(她)的朋友圈"的好友
                } catch (Exception e) {

                } finally {
                    latch.countDown();
                }
            }
        });

        executor.execute(new Runnable() {
            @Override
            public void run() {
                try{
                    //5. 去掉對你設定過"不讓他(她)看我的朋友圈"的好友
                } catch (Exception e) {

                } finally {
                    latch.countDown();
                }
            }
        });

        executor.execute(new Runnable() {
            @Override
            public void run() {
                try{
                    //6. 去掉被你拉黑和把你拉黑的好友
                } catch (Exception e) {

                } finally {
                    latch.countDown();
                }
            }
        });

        executor.execute(new Runnable() {
            @Override
            public void run() {
                try{
                    //7. 去掉被微信系統標記為作弊的好友
                } catch (Exception e) {

                } finally {
                    latch.countDown();
                }
            }
        });
        try {
            //latch.await();
            latch.await(500, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //等待所有子任務完成，彙總處理
        //8. 獲取好友最近動態再返回
    }

ExecutorService實現：

    public List<Feed> lastestFeeds(String wxId) {
        ThreadPoolExecutor executor = ...;
        CountDownLatch latch = new CountDownLatch(7);
        List<Callable<String>> tasks = new ArrayList<>(7);
        tasks.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                //1. 獲取你得好友列表
                return ...;
            }
        });
        tasks.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                //2. 去掉把你刪除的好友
                return ...;
            }
        });
        tasks.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                //3. 去掉被你刪除的好友
                return ...;
            }
        });
        tasks.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                //4. 去掉被你設定過"不看他(她)的朋友圈"的好友
                return ...;
            }
        });
        tasks.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                //5. 去掉對你設定過"不讓他(她)看我的朋友圈"的好友
                return ...;
            }
        });
        tasks.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                //6. 去掉被你拉黑和把你拉黑的好友
                return ...;
            }
        });
        tasks.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                //7. 去掉被微信系統標記為作弊的好友
                return ...;
            }
        });
        try {
//          List<Future<String>> futureList = executor.invokeAll(tasks);
            List<Future<String>> futureList = executor.invokeAll(tasks, 500, TimeUnit.MILLISECONDS);
            for(Future<String> future : futureList) {
                if(future.isCancelled()) {
                    //處理
                }
                try {
                    future.get();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

區別

兩者實現的區別是什麼？從效能上講應該是沒有太大差異，在此要感謝Doug Lea大神，感謝他優雅的實現，具體的實現，請各位看官自行百度和google。
我主要是談談這兩者使用上的細微差異，可以根據具體業務場景選擇一個更合適的。兩者在等待子任務結束時，均提供了限時和不限時版本。

如果使用限時版本

關鍵的差異在於CountDownLatch超時後不再阻塞主執行緒，而是會繼續執行，對於沒有完成的子任務，它不知道也不會處理，也就是說沒有完成的子任務還是會繼續執行。而ExecutorService.invokeAll超時後，會取消所有線上程池任務佇列中等待執行的子任務，說白了就是超時的子任務會被取消。
對於我舉的微信這個例子來說，主執行緒等待超時後，子任務再返回資料是沒有意義的，繼續執行超時的子任務只會浪費CPU而已，尤其是對於QPS較大的業務來說，影響更明顯。這種情況下選擇ExecutorService.invokeAll可能更好些，當然如果你提供額外的狀態標識如定義個AtomicBoolean來輔助實現超時不執行子任務的功能也是可以的。當然有些場景，即便主執行緒超時了，子任務也必須執行（例如子任務中涉及資料儲存，否則資料可能丟失），這種情況下，應該是使用CountDownLatch。
希望讀者諸君能夠認真體會這點差異。

對於不限時版本

兩者無太大差異，但在生產環境中要慎用，因為它不可控。

其它

另外再一點要注意的是，使用CountDownLatch時子任務的結果需要通過執行緒安全的容器收集如ConcurrentHashMap等，再處理。ExecutorService.invokeAll因為返回的是List，所以可以拿到結果，但如果想通過Future找到是哪個子任務，就只能根據順序來確認了。