如何理解java8stream性能

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

創(chuàng)新互聯(lián)建站堅(jiān)持“要么做到，要么別承諾”的工作理念，服務(wù)領(lǐng)域包括：成都網(wǎng)站建設(shè)、網(wǎng)站制作、企業(yè)官網(wǎng)、英文網(wǎng)站、手機(jī)端網(wǎng)站、網(wǎng)站推廣等服務(wù)，滿足客戶于互聯(lián)網(wǎng)時代的虹口網(wǎng)站設(shè)計、移動媒體設(shè)計的需求，幫助企業(yè)找到有效的互聯(lián)網(wǎng)解決方案。努力成為您成熟可靠的網(wǎng)絡(luò)建設(shè)合作伙伴！

Java 8 Stream的性能到底如何？

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

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

為保證測試結(jié)果真實(shí)可信，我們將JVM運(yùn)行在-server模式下，測試數(shù)據(jù)在GB量級，測試機(jī)器采用常見的商用服務(wù)器，配置如下：

OS	CentOS 6.7 x86_64
CPU	Intel Xeon X5675, 12M Cache 3.06 GHz, 6 Cores 12 Threads
內(nèi)存	96GB
JDK	java version 1.8.0_91, Java HotSpot(TM) 64-Bit Server VM

測試方法和測試數(shù)據(jù)

性能測試并不是容易的事，Java性能測試更費(fèi)勁，因?yàn)樘摂M機(jī)對性能的影響很大，JVM對性能的影響有兩方面：

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

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

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

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

實(shí)驗(yàn)一 基本類型迭代

測試內(nèi)容：找出整型數(shù)組中的最小值。對比for循環(huán)外部迭代和Stream API內(nèi)部迭代性能。

測試程序代碼：

/**
 * 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();}}}

測試結(jié)果如下圖：

圖中展示的是for循環(huán)外部迭代耗時為基準(zhǔn)的時間比值。分析如下：

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

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

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

分析，對于基本類型：

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

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

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

實(shí)驗(yàn)二 對象迭代

再來看對象的迭代效果。

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

測試程序代碼：

/**
 * 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;}}

測試結(jié)果如下圖：

結(jié)果分析如下：

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

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

再來單獨(dú)考察Stream并行迭代效果：

分析，對于對象類型：

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

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

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

實(shí)驗(yàn)三 復(fù)雜對象歸約

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

測試內(nèi)容：給定訂單列表，統(tǒng)計每個用戶的總交易額。對比使用外部迭代手動實(shí)現(xiàn)和Stream API之間的性能。

我們將訂單簡化為<userName, price, timeStamp>構(gòu)成的元組，并用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;}}

測試結(jié)果如下圖：

分析，對于復(fù)雜的歸約操作：

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

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

分析，對于復(fù)雜的歸約操作：

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

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

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

結(jié)論

上述三個實(shí)驗(yàn)的結(jié)果可以總結(jié)如下：

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

2. 對于復(fù)雜操作，Stream串行API性能可以和手動實(shí)現(xiàn)的效果匹敵，在并行執(zhí)行時Stream API效果遠(yuǎn)超手動實(shí)現(xiàn)。

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

如果出于代碼簡潔性考慮，使用Stream API能夠?qū)懗龈痰拇a。即使是從性能方面說，盡可能的使用Stream API也另外一個優(yōu)勢，那就是只要Java Stream類庫做了升級優(yōu)化，代碼不用做任何修改就能享受到升級帶來的好處。

感謝各位的閱讀，以上就是“如何理解java8 stream性能”的內(nèi)容了，經(jīng)過本文的學(xué)習(xí)后，相信大家對如何理解java8 stream性能這一問題有了更深刻的體會，具體使用情況還需要大家實(shí)踐驗(yàn)證。這里是創(chuàng)新互聯(lián)，小編將為大家推送更多相關(guān)知識點(diǎn)的文章，歡迎關(guān)注！

網(wǎng)站標(biāo)題：如何理解java8stream性能
URL地址：http://bm7419.com/article12/jjdpdc.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供響應(yīng)式網(wǎng)站、網(wǎng)站收錄、虛擬主機(jī)、動態(tài)網(wǎng)站、搜索引擎優(yōu)化、網(wǎng)站導(dǎo)航

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點(diǎn)不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源： 創(chuàng)新互聯(lián)