求求你們了，別再亂用 parallelStream 了，速度竟然比 Stream 還要慢！！

parallelStream 一定更快嗎？大家都知道 Stream 分為順序流和並行流： stream（順序流） parallelStream（並行流）它們最大的區別就是 parallelStream 支持並行化處理，所以效率較 stream（順序流）肯定是要更快的。這篇不會介紹 Stream ...

parallelStream 一定更快嗎？

大家都知道 Stream 分為順序流和並行流：

stream（順序流）
parallelStream（並行流）

它們最大的區別就是 parallelStream 支持並行化處理，所以效率較 stream（順序流）肯定是要更快的。這篇不會介紹 Stream 基礎，Stream 系列我之前寫過一個專題了，不懂的關註公眾號Java技術棧，然後在公眾號 Java 教程菜單中閱讀。

然而你確定 parallelStream 一定要更快嗎？

棧長寫了一段排序的示例，分別用 stream 和 parallelStream，對 100 ~ 10000000 條數據的集合進行排序，來看下執行效率究竟如何！

順序流排序：

/**
 * 順序流排序
 * @author: 棧長
 * @from: 公眾號Java技術棧
 */
private static void streamSort() {
    long start = System.currentTimeMillis();
    List<SortTest.User> list = new ArrayList<>(LIST);

    list.stream().sorted(SortTest.User::compareAge).collect(Collectors.toList());

    System.out.println("\nList size: " + list.size() + " Stream.sorted: " + (System.currentTimeMillis() - start));
}

並行流排序：

/**
 * 並行流排序
 * @author: 棧長
 * @from: 公眾號Java技術棧
 */
private static void parallelStreamSort() {
    long start = System.currentTimeMillis();
    List<SortTest.User> list = new ArrayList<>(LIST);

    list.parallelStream().sorted(SortTest.User::compareAge).collect(Collectors.toList());

    System.out.println("List size: " + list.size() + " ParallelStream.sorted: " + (System.currentTimeMillis() - start));
}

本文所有完整示例源代碼已經上傳：

https://github.com/javastacks/javastack

執行結果如下：

List size: 10000000 Stream.sorted: 202
List size: 10000000 ParallelStream.sorted: 402

List size: 1000000 Stream.sorted: 53
List size: 1000000 ParallelStream.sorted: 15

List size: 100000 Stream.sorted: 1
List size: 100000 ParallelStream.sorted: 2

List size: 10000 Stream.sorted: 0
List size: 10000 ParallelStream.sorted: 1

List size: 1000 Stream.sorted: 0
List size: 1000 ParallelStream.sorted: 1

List size: 100 Stream.sorted: 0
List size: 100 ParallelStream.sorted: 0

在 100000 以下是沒什麼區別的；

在 1000000 左右 ParallelStream 雖然領先 Stream，但也不是絕對每次都領先，經過不斷測試，這個數據量區間的測試兩者會互相領先；

在 10000000 左右就很穩定了，ParallelStream 幾乎比 Stream 慢了 2 倍！

現在你可能會有疑問了，為什麼會這樣？

棧長起初也有疑問，並行流（ParallelStream）怎麼會比順序流（Stream）還要慢。。

其實我後面想想也就明白了，並行流（ParallelStream）的背後其實是 Java7 開始支持的 Fork/Join，即把一個大任務拆分成 N 個小任務，然後最終合併各個子任務的結果，所以對於子任務線程的拆分、創建、結果合併等操作都需要不少的開銷，特別是線程的創建。

所以這種不耗時的簡單排序操作事實上是不適用於並行流（ParallelStream）的，它所帶來的線程創建的損耗可能還會比順序流（Stream）還要更慢。

最新 Java 8+ 面試題也都整理好了，點擊Java面試庫小程式線上刷題。

什麼時候用 ParallelStream？

既然使用 Fork/Join 是會有損耗的，那對於單條數據的處理的時間最好是理論上要超過用並行流（ParallelStream）本身的損耗，這種情況下就比較合適。

也就是說，如果對於流中的每條數據的處理比較費時間，並且沒有順序要求，這種場景下用並行流（ParallelStream）會更快，更合適。

來看下麵這個示例：

順序流數據處理：

/**
 * 順序流數據處理
 * @author: 棧長
 * @from: 公眾號Java技術棧
 */
private static void streamProcess() {
    long start = System.currentTimeMillis();
    List<SortTest.User> list = new ArrayList<>(LIST);

    list.stream().map(StreamSpeedTest::process).collect(Collectors.toList());

    System.out.println("\nList size: " + list.size() + " Stream process: " + (System.currentTimeMillis() - start));
}

並行流數據處理：

/**
 * 並行流數據處理
 * @author: 棧長
 * @from: 公眾號Java技術棧
 */
private static void parallelStreamProcess() {
    long start = System.currentTimeMillis();
    List<SortTest.User> list = new ArrayList<>(LIST);

    list.parallelStream().map(StreamSpeedTest::process).collect(Collectors.toList());

    System.out.println("List size: " + list.size() + " ParallelStream process: " + (System.currentTimeMillis() - start));
}

數據處理：

/**
 * 數據處理
 * @author: 棧長
 * @from: 公眾號Java技術棧
 */
private static SortTest.User process(SortTest.User user) {
    try {
        user.setName(user.getName() + ": process");
        Thread.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return user;
}

註意： 這裡加了個休眠 5 毫秒，為了體現真實的處理數據耗時。

本文所有完整示例源代碼已經上傳：

https://github.com/javastacks/javastack

並行流排序：

List size: 1000 Stream process: 5750
List size: 1000 ParallelStream process: 745

List size: 100 Stream process: 566
List size: 100 ParallelStream process: 77

結果很明顯了，不管測試多少次，並行流（ParallelStream）的處理速度都要比順序流（Stream）要快幾倍！！我這裡只測試了 100 和 1000 條數據，因為 10000 條以上的數據用順序流（Stream）可能要等非常久。

而且我程式中的處理邏輯只休眠了 5 毫秒，如果實際處理單條數據的耗時要比這個更長，那並行流（ParallelStream）的處理效率還會更明顯。