Java stream性能比较

news/2024/11/17 4:56:55/

环境

  • Ubuntu 22.04
  • IntelliJ IDEA 2022.1.3
  • JDK 17
  • CPU：8核
➜  ~ cat /proc/cpuinfo | egrep -ie 'physical id|cpu cores'
physical id	: 0
cpu cores	: 1
physical id	: 2
cpu cores	: 1
physical id	: 4
cpu cores	: 1
physical id	: 6
cpu cores	: 1
physical id	: 8
cpu cores	: 1
physical id	: 10
cpu cores	: 1
physical id	: 12
cpu cores	: 1
physical id	: 14
cpu cores	: 1

目标

文本通过实际测试，从以下几个维度比较Java stream的性能：

  • stream VS. parallelStream
  • 分步 VS. 总体，分步指的是每次操作都转换为List，下个操作前再转换为stream，而总体指的是全部操作之后再转换为List。显然，总体的性能会好于分步的性能
  • 不同数据量对性能的影响

准备

新建maven项目 test0317 。

打开 pom.xml 文件，添加如下内容：

        <!-- https://mvnrepository.com/artifact/junit/junit --><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13.2</version><scope>test</scope></dependency>

在 src/test/java/com.example.test0317 目录下创建package package1 ，并创建类 Test0317 ：

package com.example.test0317.package1;import org.junit.Test;import java.util.List;
import java.util.stream.Stream;public class Test0317 {private List<Double> list1 = null;private long size = 10000000;private long start = 0;private long end = 0;private long time = 0;
}

测试

测试1（stream，10000000，分步）

    @Testpublic void test1() {System.out.println("\n****** test1: stream, " + size + ", step by step ******");for (int i = 0; i < 3; i++) {list1 = Stream.generate(Math::random).limit(size).toList();start = System.currentTimeMillis();list1 = list1.stream().map(e -> e + 1).toList();list1 = list1.stream().map(e -> e * 2).toList();list1 = list1.stream().sorted().toList();end = System.currentTimeMillis();time = end - start;System.out.println("time = " + time);}}

运行结果如下：

****** test1: stream, 10000000, step by step ******
time = 6062
time = 5931
time = 6917

测试2（parallelStream，10000000，分步）

    @Testpublic void test2() {System.out.println("\n****** test2: parallelStream, " + size + ", step by step ******");for (int i = 0; i < 3; i++) {list1 = Stream.generate(Math::random).limit(10000000).toList();start = System.currentTimeMillis();list1 = list1.parallelStream().map(e -> e + 1).toList();list1 = list1.parallelStream().map(e -> e * 2).toList();list1 = list1.parallelStream().sorted().toList();end = System.currentTimeMillis();time = end - start;System.out.println("time = " + time);}}

运行结果如下：

****** test2: parallelStream, 10000000, step by step ******
time = 2038
time = 1822
time = 2000

测试3（stream，10000000，总体）

    @Testpublic void test3() {System.out.println("\n****** test3: stream, " + size + ", whole ******");for (int i = 0; i < 3; i++) {list1 = Stream.generate(Math::random).limit(10000000).toList();start = System.currentTimeMillis();list1 = list1.stream().map(e -> e + 1).map(e -> e * 2).sorted().toList();end = System.currentTimeMillis();time = end - start;System.out.println("time = " + time);}}

运行结果如下：

****** test3: stream, 10000000, whole ******
time = 6118
time = 5774
time = 6310

测试4（parallelStream，10000000，总体）

    @Testpublic void test4() {System.out.println("\n****** test4: parallelStream, " + size + ", whole ******");for (int i = 0; i < 3; i++) {list1 = Stream.generate(Math::random).limit(10000000).toList();start = System.currentTimeMillis();list1 = list1.parallelStream().map(e -> e + 1).map(e -> e * 2).sorted().toList();end = System.currentTimeMillis();time = end - start;System.out.println("time = " + time);}}

运行结果如下：

****** test4: parallelStream, 10000000, whole ******
time = 1771
time = 1873
time = 2011

测试5（stream，20000000，分步）

运行结果如下：

****** test1: stream, 20000000, step by step ******
time = 12870
time = 12642
time = 12425

测试6（parallelStream，20000000，分步）

运行结果如下：

****** test2: parallelStream, 20000000, step by step ******
time = 4216
time = 4247
time = 4420

测试7（stream，20000000，总体）

运行结果如下：

****** test3: stream, 20000000, whole ******
time = 12199
time = 12136
time = 12088

测试8（parallelStream，20000000，总体）

运行结果如下：

****** test4: parallelStream, 20000000, whole ******
time = 3526
time = 3796
time = 4105

上面的测试中，因为CPU是8核，所以parallelStream最多使用8个线程，而下面的测试是指定使用2线程，方法为在JVM的启动选项（VM options）里设置 -Djava.util.concurrent.ForkJoinPool.common.parallelism=2 ，如下图所示：

在这里插入图片描述

测试9（2线程，parallelStream，10000000，分步）

运行结果如下：

****** test2: parallelStream, 10000000, step by step ******
time = 3446
time = 3246
time = 3523

测试10（2线程，parallelStream，10000000，总体）

运行结果如下：

****** test4: parallelStream, 10000000, whole ******
time = 3173
time = 3136
time = 3259

测试11（2线程，parallelStream，20000000，分步）

运行结果如下：

****** test2: parallelStream, 20000000, step by step ******
time = 7246
time = 7830
time = 7613

测试12（2线程，parallelStream，20000000，总体）

运行结果如下：

****** test4: parallelStream, 20000000, whole ******
time = 7292
time = 7438
time = 7109

总结

测试结果总结如下：

stream VS. parallelStreamstepwise VS. whole元素个数平均时间（秒）速度提升
测试1streamstepwise100000006.3baseline
测试2parallelStreamstepwise100000002.03.15
测试3streamwhole100000006.11.03
测试4parallelStreamwhole100000001.93.32

总结：在8核，10000000个元素的情况下，parallelStream相比stream性能提升很大，而总体相比分步只是略有性能提升。

如果把10000000个元素换为20000000个元素，测试结果如下：

stream VS. parallelStreamstepwise VS. whole元素个数平均时间（秒）速度提升
测试5streamstepwise2000000012.6baseline
测试6parallelStreamstepwise200000004.32.93
测试7streamwhole2000000012.11.04
测试8parallelStreamwhole200000003.83.32

可见，如果元素个数加倍，则对于每个测试结果，运行时间也都几乎加倍，符合线性增长。

总结：在8核，20000000个元素的情况下，parallelStream相比stream性能提升很大，而总体相比分步只是略有性能提升。

另外，若换成2线程，其性能显然在单线程和8线程之间。测试结果如下：

stream VS. parallelStreamstepwise VS. whole元素个数平均时间（秒）速度提升
测试9parallelStreamstepwise100000003.31.91
测试10parallelStreamwhole100000003.12.03
测试11parallelStreamstepwise200000007.61.66
测试12parallelStreamwhole200000007.31.73

可见，2线程相比单线程，性能提升接近于2倍，但是达不到2倍，这是因为创建和切换线程需要消耗一定的时间和资源，同理，拆分及合并数据也需要消耗一定的时间和资源。

总结：在2线程，10000000或20000000个元素的情况下，parallelStream相比stream的性能提升接近于2倍，而总体相比分步只是略有性能提升。

最后多说一句：在数据量很大（本例中达到千万级别）时，parallelStream相比stream而言，性能有非常大的提升。但是若数据量不大，比如我测试了10000，则parallelStream相比stream，性能不但没有提升，甚至变得更差了，原因前面已经提到了。

不过话说回来，即使parallelStream比起stream性能变差，但因为数据量小，所以消耗的时间总量就少，比如说假设从10毫秒变成15毫秒，虽然多了50%的时间消耗，但是因为绝对值很小，所以问题不大。

从这个角度看来，还是应该尽量用parallelStream来取代stream。

当然，本例只是一个非常简单的模型，在一些复杂的情况下，比如有线程安全的问题，就要考虑应该用stream还是parallelStream。


http://www.ppmy.cn/news/35218.html

相关文章

hexo 搭建个人博客记录

hexo 搭建个人博客记录

看B站的程序羊的关于搭建hexo博客的方法自己搭了一个博客&#xff0c;链接是 手把手教你从0开始搭建自己的个人博客 |无坑版视频教程| hexo 下面就视频所讲做做笔记&#xff0c;以后可以回来查看&#xff0c;推荐小伙伴想搭建hexo博客的可以去看看这个视频。 1. 安装Node.js…
阅读更多...
javascript基础（二）

javascript基础（二）

17 事件处理JS 事件&#xff08;event&#xff09;是当用户与网页进行交互时发生的事情&#xff0c;例如单机某个链接或按钮、在文本框中输入文本、按下键盘上的某个按键、移动鼠标等等。当事件发生时&#xff0c;您可以使用 JavaScript 中的事件处理程序&#xff08;也可称为事…
阅读更多...
电路基础_模拟电路_问答_2023_01

电路基础_模拟电路_问答_2023_01

模拟电路 &#xff08;数学、电路、编程、信号处理&#xff09; 模拟电路的历史可以追溯到19世纪初&#xff0c;当时电学理论才刚刚开始发展。经过多年的研究和实践&#xff0c;一些重要的电学定律和基本电路结构被发现和建立&#xff0c;如欧姆定律、基尔霍夫定律、戴维南-诺…
阅读更多...
【数据结构】顺序表的深度刨剖析

【数据结构】顺序表的深度刨剖析

前言&#xff1a;在上一篇文章中&#xff0c;我们已经对数据结构有了一定了解&#xff0c;我们可以通过优化空间复杂度或者时间复杂度从而提高我们程序运行或存储速率。至此我们就知道了数据结构的重要性&#xff0c;所以今天我们将要了解和学习一种实用的数据结构——线性表。…
阅读更多...
中科亿海微FPGA应用(一、点灯)

中科亿海微FPGA应用(一、点灯)

1.软件&#xff1a; https://download.csdn.net/download/weixin_41784968/87564071 需要申请license才能使用&#xff1a;软件试用申请_软件试用申请_中科亿海微电子科技&#xff08;苏州&#xff09;有限公司 2.开发板&#xff1a; 芯片EQ6HL45&#xff0c;42.5k LUT。 3…
阅读更多...
Autosar诊断-DCM模块内的子模块

Autosar诊断-DCM模块内的子模块

文章目录 前言一、DCM模块内的子模块1.1、DSL（Diagnostic Session Layer）1.2、DSD（Diagnostic Service Dispatcher）1.3、DSP（Diagnostic Service Processing）二、DCM和其他模块的交互2.1 DCM和PduR的交互2.2 DCM和ComM的交互总结前言 诊断通信管理(Diagnostic Communica…
阅读更多...
摄影入门 | 相机的基本原理

摄影入门 | 相机的基本原理

一、获取图像——小孔成像实验 小孔成像实验中&#xff0c;点燃蜡烛&#xff0c;会在小孔另一面的白纸上看到一个倒立的烛焰。 此现象可以用来解释物理学原理&#xff1a;光在同种均匀介质中&#xff0c;在不受引力作用干扰的情况下沿直线传播。 这样&#xff0c;我们就用一种…
阅读更多...
【CE进阶】lua脚本使用

【CE进阶】lua脚本使用

▒ 目录 ▒&#x1f6eb; 导读需求开发环境1️⃣ 脚本窗口Lua ScriptLua EngineAuto assemble2️⃣ 全局变量3️⃣ 进程当前打开的进程ID系统的进程列表系统的顶部窗口列表4️⃣ 线程5️⃣ 输入设备6️⃣ 屏幕7️⃣ 剪贴板&#x1f6ec; 文章小结&#x1f4d6; 参考资料&#x…
阅读更多...
最新文章

Copyright @ 2022~2023