如何理解java8 stream性能

這篇文章主要講解了“如何理解java8 stream性能”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“如何理解java8 stream性能”吧！

Java 8 Stream的性能到底如何？

之前的文章中我們介紹了Java 8中Stream相關的API，我們提到Stream API可以極大提高Java程序員的生產力，讓程序員寫出高效率、干凈、簡潔的代碼。

那么，Stream API的性能到底如何呢，代碼整潔的背后是否意味著性能的損耗呢？本文我們對Stream API的性能一探究竟。

為保證測試結果真實可信，我們將JVM運行在-server模式下，測試數據在GB量級，測試機器采用常見的商用服務器，配置如下：

測試方法和測試數據

性能測試并不是容易的事，Java性能測試更費勁，因為虛擬機對性能的影響很大，JVM對性能的影響有兩方面：

1. GC的影響。GC的行為是Java中很不好控制的一塊，為增加確定性，我們手動指定使用CMS收集器，并使用10GB固定大小的堆內存。具體到JVM參數就是-XX:+UseConcMarkSweepGC -Xms10G -Xmx10G

2. JIT(Just-In-Time)即時編譯技術。即時編譯技術會將熱點代碼在JVM運行的過程中編譯成本地代碼，測試時我們會先對程序預熱，觸發對測試函數的即時編譯。相關的JVM參數是-XX:CompileThreshold=10000。

Stream并行執行時用到ForkJoinPool.commonPool()得到的線程池，為控制并行度我們使用Linux的taskset命令指定JVM可用的核數。

測試數據由程序隨機生成。為防止一次測試帶來的抖動，測試4次求出平均時間作為運行時間。

實驗一 基本類型迭代

測試內容：找出整型數組中的最小值。對比for循環外部迭代和Stream API內部迭代性能。

測試程序代碼：

/**
 * java -server -Xms10G -Xmx10G -XX:+PrintGCDetails 
 * -XX:+UseConcMarkSweepGC -XX:CompileThreshold=1000 lee/IntTest
 * taskset -c 0-[0,1,3,7] java ...
 * @author CarpenterLee
 */public class IntTest {public static void main(String[] args) {new IntTest().doTest();}public void doTest(){warmUp();int[] lengths = {10000, 100000, 1000000, 10000000, 100000000, 1000000000};for(int length : lengths){System.out.println(String.format("---array length: %d---", length));int[] arr = new int[length];randomInt(arr);int times = 4;int min1 = 1;int min2 = 2;int min3 = 3;long startTime;startTime = System.nanoTime();for(int i=0; i<times; i++){min1 = minIntFor(arr);}TimeUtil.outTimeUs(startTime, "minIntFor time:", times);startTime = System.nanoTime();for(int i=0; i<times; i++){min2 = minIntStream(arr);}TimeUtil.outTimeUs(startTime, "minIntStream time:", times);startTime = System.nanoTime();for(int i=0; i<times; i++){min3 = minIntParallelStream(arr);}TimeUtil.outTimeUs(startTime, "minIntParallelStream time:", times);System.out.println(min1==min2 && min2==min3);}}private void warmUp(){int[] arr = new int[100];randomInt(arr);for(int i=0; i<20000; i++){//          minIntFor(arr);minIntStream(arr);minIntParallelStream(arr);}}private int minIntFor(int[] arr){int min = Integer.MAX_VALUE;for(int i=0; i<arr.length; i++){if(arr[i]<min)min = arr[i];}return min;}private int minIntStream(int[] arr){return Arrays.stream(arr).min().getAsInt();}private int minIntParallelStream(int[] arr){return Arrays.stream(arr).parallel().min().getAsInt();}private void randomInt(int[] arr){Random r = new Random();for(int i=0; i<arr.length; i++){arr[i] = r.nextInt();}}}

測試結果如下圖：

圖中展示的是for循環外部迭代耗時為基準的時間比值。分析如下：

1. 對于基本類型Stream串行迭代的性能開銷明顯高于外部迭代開銷（兩倍）；

2. Stream并行迭代的性能比串行迭代和外部迭代都好。

并行迭代性能跟可利用的核數有關，上圖中的并行迭代使用了全部12個核，為考察使用核數對性能的影響，我們專門測試了不同核數下的Stream并行迭代效果：

分析，對于基本類型：

1. 使用Stream并行API在單核情況下性能很差，比Stream串行API的性能還差；

2. 隨著使用核數的增加，Stream并行效果逐漸變好，比使用for循環外部迭代的性能還好。

以上兩個測試說明，對于基本類型的簡單迭代，Stream串行迭代性能更差，但多核情況下Stream迭代時性能較好。

實驗二 對象迭代

再來看對象的迭代效果。

測試內容：找出字符串列表中最小的元素（自然順序），對比for循環外部迭代和Stream API內部迭代性能。

測試程序代碼：

/**
 * java -server -Xms10G -Xmx10G -XX:+PrintGCDetails 
 * -XX:+UseConcMarkSweepGC -XX:CompileThreshold=1000 lee/StringTest
 * taskset -c 0-[0,1,3,7] java ...
 * @author CarpenterLee
 */public class StringTest {public static void main(String[] args) {new StringTest().doTest();}public void doTest(){warmUp();int[] lengths = {10000, 100000, 1000000, 10000000, 20000000, 40000000};for(int length : lengths){System.out.println(String.format("---List length: %d---", length));ArrayList<String> list = randomStringList(length);int times = 4;String min1 = "1";String min2 = "2";String min3 = "3";long startTime;startTime = System.nanoTime();for(int i=0; i<times; i++){min1 = minStringForLoop(list);}TimeUtil.outTimeUs(startTime, "minStringForLoop time:", times);startTime = System.nanoTime();for(int i=0; i<times; i++){min2 = minStringStream(list);}TimeUtil.outTimeUs(startTime, "minStringStream time:", times);startTime = System.nanoTime();for(int i=0; i<times; i++){min3 = minStringParallelStream(list);   }TimeUtil.outTimeUs(startTime, "minStringParallelStream time:", times);System.out.println(min1.equals(min2) && min2.equals(min3));//          System.out.println(min1);}}private void warmUp(){ArrayList<String> list = randomStringList(10);for(int i=0; i<20000; i++){minStringForLoop(list);minStringStream(list);minStringParallelStream(list);}}private String minStringForLoop(ArrayList<String> list){String minStr = null;boolean first = true;for(String str : list){if(first){first = false;minStr = str;}if(minStr.compareTo(str)>0){minStr = str;}}return minStr;}private String minStringStream(ArrayList<String> list){return list.stream().min(String::compareTo).get();}private String minStringParallelStream(ArrayList<String> list){return list.stream().parallel().min(String::compareTo).get();}private ArrayList<String> randomStringList(int listLength){ArrayList<String> list = new ArrayList<>(listLength);Random rand = new Random();int strLength = 10;StringBuilder buf = new StringBuilder(strLength);for(int i=0; i<listLength; i++){buf.delete(0, buf.length());for(int j=0; j<strLength; j++){buf.append((char)('a'+rand.nextInt(26)));}list.add(buf.toString());}return list;}}

測試結果如下圖：

結果分析如下：

1. 對于對象類型Stream串行迭代的性能開銷仍然高于外部迭代開銷（1.5倍），但差距沒有基本類型那么大。

2. Stream并行迭代的性能比串行迭代和外部迭代都好。

再來單獨考察Stream并行迭代效果：

分析，對于對象類型：

1. 使用Stream并行API在單核情況下性能比for循環外部迭代差；

2. 隨著使用核數的增加，Stream并行效果逐漸變好，多核帶來的效果明顯。

以上兩個測試說明，對于對象類型的簡單迭代，Stream串行迭代性能更差，但多核情況下Stream迭代時性能較好。

實驗三 復雜對象歸約

從實驗一、二的結果來看，Stream串行執行的效果都比外部迭代差（很多），是不是說明Stream真的不行了？先別下結論，我們再來考察一下更復雜的操作。

測試內容：給定訂單列表，統計每個用戶的總交易額。對比使用外部迭代手動實現和Stream API之間的性能。

我們將訂單簡化為<userName, price, timeStamp>構成的元組，并用Order對象來表示。

測試程序代碼：

/**
 * java -server -Xms10G -Xmx10G -XX:+PrintGCDetails 
 * -XX:+UseConcMarkSweepGC -XX:CompileThreshold=1000 lee/ReductionTest
 * taskset -c 0-[0,1,3,7] java ...
 * @author CarpenterLee
 */public class ReductionTest {public static void main(String[] args) {new ReductionTest().doTest();}public void doTest(){warmUp();int[] lengths = {10000, 100000, 1000000, 10000000, 20000000, 40000000};for(int length : lengths){System.out.println(String.format("---orders length: %d---", length));List<Order> orders = Order.genOrders(length);int times = 4;Map<String, Double> map1 = null;Map<String, Double> map2 = null;Map<String, Double> map3 = null;long startTime;startTime = System.nanoTime();for(int i=0; i<times; i++){map1 = sumOrderForLoop(orders);}TimeUtil.outTimeUs(startTime, "sumOrderForLoop time:", times);startTime = System.nanoTime();for(int i=0; i<times; i++){map2 = sumOrderStream(orders);}TimeUtil.outTimeUs(startTime, "sumOrderStream time:", times);startTime = System.nanoTime();for(int i=0; i<times; i++){map3 = sumOrderParallelStream(orders);  }TimeUtil.outTimeUs(startTime, "sumOrderParallelStream time:", times);System.out.println("users=" + map3.size());}}private void warmUp(){List<Order> orders = Order.genOrders(10);for(int i=0; i<20000; i++){sumOrderForLoop(orders);sumOrderStream(orders);sumOrderParallelStream(orders);}}private Map<String, Double> sumOrderForLoop(List<Order> orders){Map<String, Double> map = new HashMap<>();for(Order od : orders){String userName = od.getUserName();Double v; if((v=map.get(userName)) != null){map.put(userName, v+od.getPrice());}else{map.put(userName, od.getPrice());}}return map;}private Map<String, Double> sumOrderStream(List<Order> orders){return orders.stream().collect(Collectors.groupingBy(Order::getUserName, Collectors.summingDouble(Order::getPrice)));}private Map<String, Double> sumOrderParallelStream(List<Order> orders){return orders.parallelStream().collect(Collectors.groupingBy(Order::getUserName, Collectors.summingDouble(Order::getPrice)));}}class Order{private String userName;private double price;private long timestamp;public Order(String userName, double price, long timestamp) {this.userName = userName;this.price = price;this.timestamp = timestamp;}public String getUserName() {return userName;}public double getPrice() {return price;}public long getTimestamp() {return timestamp;}public static List<Order> genOrders(int listLength){ArrayList<Order> list = new ArrayList<>(listLength);Random rand = new Random();int users = listLength/200;// 200 orders per userusers = users==0 ? listLength : users;ArrayList<String> userNames = new ArrayList<>(users);for(int i=0; i<users; i++){userNames.add(UUID.randomUUID().toString());}for(int i=0; i<listLength; i++){double price = rand.nextInt(1000);String userName = userNames.get(rand.nextInt(users));list.add(new Order(userName, price, System.nanoTime()));}return list;}@Overridepublic String toString(){return userName + "::" + price;}}

測試結果如下圖：

分析，對于復雜的歸約操作：

1. Stream API的性能普遍好于外部手動迭代，并行Stream效果更佳；

再來考察并行度對并行效果的影響，測試結果如下：

分析，對于復雜的歸約操作：

1. 使用Stream并行歸約在單核情況下性能比串行歸約以及手動歸約都要差，簡單說就是最差的；

2. 隨著使用核數的增加，Stream并行效果逐漸變好，多核帶來的效果明顯。

以上兩個實驗說明，對于復雜的歸約操作，Stream串行歸約效果好于手動歸約，在多核情況下，并行歸約效果更佳。我們有理由相信，對于其他復雜的操作，Stream API也能表現出相似的性能表現。

結論

上述三個實驗的結果可以總結如下：

1. 對于簡單操作，比如最簡單的遍歷，Stream串行API性能明顯差于顯示迭代，但并行的Stream API能夠發揮多核特性。

2. 對于復雜操作，Stream串行API性能可以和手動實現的效果匹敵，在并行執行時Stream API效果遠超手動實現。

所以，如果出于性能考慮，1. 對于簡單操作推薦使用外部迭代手動實現，2. 對于復雜操作，推薦使用Stream API， 3. 在多核情況下，推薦使用并行Stream API來發揮多核優勢，4.單核情況下不建議使用并行Stream API。

如果出于代碼簡潔性考慮，使用Stream API能夠寫出更短的代碼。即使是從性能方面說，盡可能的使用Stream API也另外一個優勢，那就是只要Java Stream類庫做了升級優化，代碼不用做任何修改就能享受到升級帶來的好處。

感謝各位的閱讀，以上就是“如何理解java8 stream性能”的內容了，經過本文的學習后，相信大家對如何理解java8 stream性能這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！