爲什麼迭代列表需要更多的時間，如果Java 8流功能使用？

Question

public static void main(String[] args) { 
     List<String> data = new ArrayList<>(); 
     for (int i = 0; i < 10000000; i++) { 
      data.add("data" + i); 
     } 
     System.out.println("parallel stream start time" + System.currentTimeMillis()); 
     data.parallelStream().forEach(x -> { 
      System.out.println("data -->" + x); 
     }); 
     System.out.println("parallel stream end time" + System.currentTimeMillis()); 

     System.out.println("simple stream start time" + System.currentTimeMillis()); 
     data.stream().forEach(x -> { 
      System.out.println("data -->" + x); 
     }); 
     System.out.println("simple stream end time" + System.currentTimeMillis()); 

     System.out.println("normal foreach start time" + System.currentTimeMillis()); 
     for (int i = 0; i < data.size(); i++) { 
      System.out.println("data -->" + data.get(i)); 
     } 
     System.out.println("normal foreach end time" + System.currentTimeMillis()); 
    } 

輸出

並行流開始時間1501944014854

並行流結束時間1501944014970

簡單流開始時間1501944014970

簡單流結束時間1501944015036

正常的foreach STA室溫時間1501944015036

正常的foreach結束時間1501944015040

的全部時間

簡單流 - > 66

Parellem流 - > 116

簡單的foreach - > 4

在很多寫過parallelStream的並行執行的博客中，b y內部管理分佈式任務之間的線程和自動收集。

但根據上述實驗，很明顯注意到並行流花費更多的時間，然後簡單的流和正常的foreach。

爲什麼平行執行需要更多時間？在項目中使用這個功能會降低性能嗎？

由於提前

Answer 1

1. 你的測試基於I/O操作（最昂貴的操作）
2. 如果你想使用並行流，你必須採取線程創建的時間開銷考慮到了。所以，只有當你的操作從中受益，然後使用它（這是重型操作的情況）。如果不是，那麼只需使用普通流或常規的for-loop。

---

測量的基本規則：

1. 不要使用I/O操作。
2. 重複相同的測試更多然後只是一次。

因此，如果我們不得不再次重新制定測試方案，那麼我們可能有一個測試輔助類定義如下：

import java.util.HashMap; 
import java.util.Map; 
import java.util.UUID; 

public class Benchmark { 

    public static <T> T performTest(Callable<T> callable, int iteration, String name) throws Exception { 
     Map<String, Iteraion> map = new HashMap<>(); 
     T last = null; 
     for (int i = 0; i < iteration; i++) { 
      long s = System.nanoTime(); 
      T temp = callable.call(); 
      long f = System.nanoTime(); 
      map.put(UUID.randomUUID().toString(), new Iteraion(s, f)); 
      if (i == iteration - 1) { 
       last = temp; 
      } 
     } 
     System.out.print("TEST :\t" + name + "\t\t\t"); 
     System.out.print("ITERATION: " + map.size()); 
     long sum = 0l; 
     for (String i : map.keySet()) { 
      sum += (map.get(i).finish - map.get(i).start); 
     } 
     long avg = (sum/map.size())/1000000; 
     System.out.println("\t\t\tAVERAGE: " + avg + " ms"); 
     return last; 

    } 

    public interface Callable<T> { 
     T call() throws Exception; 
    } 

    static class Iteraion { 
     Long start; 
     Long finish; 

     public Iteraion(Long s, Long f) { 
      start = s; 
      finish = f; 
     } 
    } 
} 

現在我們可以使用不同的執行相同的測試，曾多次操作。以下代碼顯示使用兩種不同方案執行的測試。

import java.util.ArrayList; 
import java.util.List; 
import static java.lang.Math.*; 

@SuppressWarnings("unused") 
public class Test { 

    public static void main(String[] args) { 
     try { 
      final int iteration = 100; 
      final List<String> data = new ArrayList<>(); 

      for (int i = 0; i < 10000000; i++) { 
       data.add("data" + i); 
      } 

      /** 
      * Scenario 1 
      */ 
      Benchmark.performTest(new Callable<Void>() { 

       @Override 
       public Void call() throws Exception { 
        data.parallelStream().forEach(x -> { 
         x.trim(); 
        }); 
        return (Void) null; 
       } 

      }, iteration, "PARALEL_STREAM_ASSIGN_VAL"); 

      Benchmark.performTest(new Callable<Void>() { 

       @Override 
       public Void call() throws Exception { 
        data.stream().forEach(x -> { 
         x.trim(); 
        }); 
        return (Void) null; 
       } 
      }, iteration, "NORMAL_STREAM_ASSIGN_VAL"); 

      Benchmark.performTest(new Callable<Void>() { 

       @Override 
       public Void call() throws Exception { 
        for (int i = 0; i < data.size(); i++) { 
         data.get(i).trim(); 
        } 
        return (Void) null; 
       } 
      }, iteration, "NORMAL_FOREACH_ASSIGN_VAL"); 

      /** 
      * Scenario 2 
      */ 
      Benchmark.performTest(new Callable<Void>() { 

       @Override 
       public Void call() throws Exception { 
        data.parallelStream().forEach(x -> { 
         Integer i = Integer.parseInt(x.substring(4, x.length())); 
         double d = tan(atan(tan(atan(i)))); 
        }); 
        return (Void) null; 
       } 

      }, iteration, "PARALEL_STREAM_COMPUTATION"); 

      Benchmark.performTest(new Callable<Void>() { 

       @Override 
       public Void call() throws Exception { 
        data.stream().forEach(x -> { 
         Integer i = Integer.parseInt(x.substring(4, x.length())); 
         double d = tan(atan(tan(atan(i)))); 
        }); 
        return (Void) null; 
       } 
      }, iteration, "NORMAL_STREAM_COMPUTATION"); 

      Benchmark.performTest(new Callable<Void>() { 

       @Override 
       public Void call() throws Exception { 
        for (int i = 0; i < data.size(); i++) { 
         Integer x = Integer.parseInt(data.get(i).substring(4, data.get(i).length())); 
         double d = tan(atan(tan(atan(x)))); 
        } 
        return (Void) null; 
       } 
      }, iteration, "NORMAL_FOREACH_COMPUTATION"); 

     } catch (Exception e) { 
      e.printStackTrace(); 
     } 

    } 
} 

1. 第一種方案使用所trim()方法相同的測試100次爲包含10_000_000元件，因此它使用並行流，則普通流和最後的一個列表老學校for循環。
2. 第二種方案使用與第一種情況相同的技術對相同列表執行一些相對較重的操作，如tan(atan(tan(atan(i))))。

---

的結果是：

// First scenario, average times 
Parallel stream: 78 ms 
Regular stream: 113 ms 
For-loop:  110 ms 

// Second scenario, average times 
Parallel stream: 1397 ms 
Regular stream: 3866 ms 
For-loop:   3826 ms 

---

請注意，您可以調試上面的代碼，那麼您注意到並行數據流的程序下名字[ForkJoinPool-1]創建三個額外的線程 ，[ForkJoinPool-2]和[ForkJoinPool-3]。

編輯： 順序流和for循環使用調用者線程。