一、粉絲的反饋
問：stream比for回圈慢5倍，用這個是為了啥？
答：互聯網是一個新聞泛濫的時代，三人成虎，以假亂真的事情時候發生，作為一個技術開發者，要自己去動手去做，不要人云亦云，
的確，這位粉絲說的這篇文章我也看過，我就不貼地址了，也沒必要給他帶流量，怎么說呢？就是一個不懂得測驗的、不入流開發工程師做的性能測驗，給出了一個危言聳聽的結論，
二、所有性能測驗結論都是片面的
性能測驗是必要的，但針對性能測驗的結果，永遠要持懷疑態度，為什么這么說？
- 性能測驗脫離業務場景就是片面的性能測驗，你能覆寫所有的業務場景么？
- 性能測驗脫離硬體環境就是片面的性能測驗，你能覆寫所有的硬體環境么？
- 性能測驗脫離開發人員的知識面就是片面的性能測驗，你能覆寫各種開發人員奇奇怪怪的代碼么？
所以，我從來不相信網上的任何性能測驗的文章，凡是我自己的從事的業務場景，我都要在接近生產環境的機器上自己測驗一遍， 所有性能測驗結論都是片面的，只有你生產環境下的運行結果才是真的，
三、動手測驗Stream的性能
3.1.環境
windows10 、16G記憶體、i7-7700HQ 2.8HZ 、64位作業系統、JDK 1.8.0_171
3.2.測驗用例與測驗結論
我們在上一節,已經講過：
- 針對不同的資料結構，Stream流的執行效率是不一樣的
- 針對不同的資料源，Stream流的執行效率也是不一樣的
所以記住筆者的話：所有性能測驗結論都是片面的，你要自己動手做，相信你自己的代碼和你的環境下的測驗！我的測驗結果僅僅代表我自己的測驗用例和測驗資料結構！
3.2.1.測驗用例一
測驗用例：5億個int亂數，求最小值
測驗結論（測驗代碼見后文）：
- 使用普通for回圈，執行效率是Stream串行流的2倍，也就是說普通for回圈性能更好，
- Stream并行流計算是普通for回圈執行效率的4-5倍，
- Stream并行流計算 > 普通for回圈 > Stream串行流計算
3.2.測驗用例二
測驗用例：長度為10的1000000隨機字串，求最小值
測驗結論（測驗代碼見后文）：
- 普通for回圈執行效率與Stream串行流不相上下
- Stream并行流的執行效率遠高于普通for回圈
- Stream并行流計算 > 普通for回圈 = Stream串行流計算
3.3.測驗用例三
測驗用例：10個用戶，每人200個訂單，按用戶統計訂單的總價，
測驗結論（測驗代碼見后文）：
- Stream并行流的執行效率遠高于普通for回圈
- Stream串行流的執行效率大于等于普通for回圈
- Stream并行流計算 > Stream串行流計算 >= 普通for回圈
四、最終測驗結論
- 對于簡單的數字(list-Int)遍歷，普通for回圈效率的確比Stream串行流執行效率高（1.5-2.5倍），但是Stream流可以利用并行執行的方式發揮CPU的多核優勢,因此并行流計算執行效率高于for回圈，
- 對于list-Object型別的資料遍歷，普通for回圈和Stream串行流比也沒有任何優勢可言，更不用提Stream并行流計算，
雖然在不同的場景、不同的資料結構、不同的硬體環境下，Stream流與for回圈性能測驗結果差異較大，甚至發生逆轉，但是總體上而言：
- Stream并行流計算 >> 普通for回圈 ~= Stream串行流計算 (之所以用兩個大于號，你細品)
- 資料容量越大，Stream流的執行效率越高，
- Stream并行流計算通常能夠比較好的利用CPU的多核優勢，CPU核心越多，Stream并行流計算效率越高，
stream比for回圈慢5倍？也許吧，單核CPU、串行Stream的int型別資料遍歷？我沒試過這種場景，但是我知道這不是應用系統的核心場景，看了十幾篇測驗博文，和我的測驗結果，我的結論是： 在大多數的核心業務場景下及常用資料結構下，Stream的執行效率比for回圈更高， 畢竟我們的業務中通常是實實在在的物體物件，沒事誰總對List<Int>型別進行遍歷？誰的生產服務器是單核？，
五、測驗代碼
<dependency>
<groupId>com.github.houbb</groupId>
<artifactId>junitperf</artifactId>
<version>2.0.0</version>
</dependency>
測驗用例一：
import com.github.houbb.junitperf.core.annotation.JunitPerfConfig;
import com.github.houbb.junitperf.core.report.impl.HtmlReporter;
import org.junit.jupiter.api.BeforeAll;
import java.util.Arrays;
import java.util.Random;
public class StreamIntTest {
public static int[] arr;
@BeforeAll
public static void init() {
arr = new int[500000000]; //5億個隨機Int
randomInt(arr);
}
@JunitPerfConfig( warmUp = 1000, reporter = {HtmlReporter.class})
public void testIntFor() {
minIntFor(arr);
}
@JunitPerfConfig( warmUp = 1000, reporter = {HtmlReporter.class})
public void testIntParallelStream() {
minIntParallelStream(arr);
}
@JunitPerfConfig( warmUp = 1000, reporter = {HtmlReporter.class})
public void testIntStream() {
minIntStream(arr);
}
private int minIntStream(int[] arr) {
return Arrays.stream(arr).min().getAsInt();
}
private int minIntParallelStream(int[] arr) {
return Arrays.stream(arr).parallel().min().getAsInt();
}
private int minIntFor(int[] arr) {
int min = Integer.MAX_VALUE;
for (int anArr : arr) {
if (anArr < min) {
min = anArr;
}
}
return min;
}
private static void randomInt(int[] arr) {
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
arr[i] = r.nextInt();
}
}
}
測驗用例二：
import com.github.houbb.junitperf.core.annotation.JunitPerfConfig;
import com.github.houbb.junitperf.core.report.impl.HtmlReporter;
import org.junit.jupiter.api.BeforeAll;
import java.util.ArrayList;
import java.util.Random;
public class StreamStringTest {
public static ArrayList<String> list;
@BeforeAll
public static void init() {
list = randomStringList(1000000);
}
@JunitPerfConfig(duration = 10000, warmUp = 1000, reporter = {HtmlReporter.class})
public void testMinStringForLoop(){
String minStr = null;
boolean first = true;
for(String str : list){
if(first){
first = false;
minStr = str;
}
if(minStr.compareTo(str)>0){
minStr = str;
}
}
}
@JunitPerfConfig(duration = 10000, warmUp = 1000, reporter = {HtmlReporter.class})
public void textMinStringStream(){
list.stream().min(String::compareTo).get();
}
@JunitPerfConfig(duration = 10000, warmUp = 1000, reporter = {HtmlReporter.class})
public void testMinStringParallelStream(){
list.stream().parallel().min(String::compareTo).get();
}
private static 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;
}
}
測驗用例三：
import com.github.houbb.junitperf.core.annotation.JunitPerfConfig;
import com.github.houbb.junitperf.core.report.impl.HtmlReporter;
import org.junit.jupiter.api.BeforeAll;
import java.util.*;
import java.util.stream.Collectors;
public class StreamObjectTest {
public static List<Order> orders;
@BeforeAll
public static void init() {
orders = Order.genOrders(10);
}
@JunitPerfConfig(duration = 10000, warmUp = 1000, reporter = {HtmlReporter.class})
public void testSumOrderForLoop(){
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());
}
}
}
@JunitPerfConfig(duration = 10000, warmUp = 1000, reporter = {HtmlReporter.class})
public void testSumOrderStream(){
orders.stream().collect(
Collectors.groupingBy(Order::getUserName,
Collectors.summingDouble(Order::getPrice)));
}
@JunitPerfConfig(duration = 10000, warmUp = 1000, reporter = {HtmlReporter.class})
public void testSumOrderParallelStream(){
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 user
users = 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;
}
@Override
public String toString(){
return userName + "::" + price;
}
}
歡迎關注我的博客，里面有很多精品合集
- 本文轉載注明出處（必須帶連接，不能只轉文字）：字母哥博客，
覺得對您有幫助的話，幫我點贊、分享！您的支持是我不竭的創作動力！ ，另外，筆者最近一段時間輸出了如下的精品內容，期待您的關注，
- 《手摸手教你學Spring Boot2.0》
- 《Spring Security-JWT-OAuth2一本通》
- 《實戰前后端分離RBAC權限管理系統》
- 《實戰SpringCloud微服務從青銅到王者》
- 《VUE深入淺出系列》
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/158281.html
標籤：Java