Java stream性能比较

环境

  • 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，分步）

    @Test
    public 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，分步）

    @Test
    public 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，总体）

    @Test
    public 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，总体）

    @Test
    public 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。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/2239.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

浏览器工作原理

浏览器工作原理

一、JavaScript 的历史 JavaScript&#xff08;简称JS&#xff09;Web前端开发的脚本语言。 它诞生1995年&#xff0c;由网景公司的 Brendan Eich 开发。最初&#xff0c;JavaScript 被设计用于在网页上嵌入动态内容和交互式功能。 1996年&#xff0c;JavaScript 1.1 成为国…
阅读更多...
C++虚函数与多态

C++虚函数与多态

C虚函数与多态虚函数抽象类纯虚函数虚析构函数多态虚函数的几个问题纯虚函数和ADT虚函数 virtual修饰的成员函数就是虚函数&#xff0c; 1.虚函数对类的内存影响&#xff1a;增加一个指针类型大小&#xff08;32位和64位&#xff09; 2.无论有多少个虚函数&#xff0c;只增加一…
阅读更多...
【ansible】模块介绍超详解（下）

【ansible】模块介绍超详解（下）

目录 六&#xff0c;软件包管理 1&#xff0c;yum_repository模块 &#xff08;1&#xff09;yum_repository模块常用选项 &#xff08;2&#xff09;yum_repository模块案例 2&#xff0c;mount模块 &#xff08;1&#xff09;mount模块选项 &#xff08;2&#xff09;mount模…
阅读更多...
大数据简介

大数据简介

大数据概论和职业规划Linux服务器系统Hadoop概论HDFS分布式文件系统Hive数据仓库SparSQL指令Zepplin框架Sqoop框架Superset数据可视化大数据数仓实战-didi出行大数据概念大数据特点大数据应用场景大数据分析业务步骤大数据职业规划大数据学习路线。大数据概念数据&#xff1a;世…
阅读更多...
基于YOLOv5的舰船检测与识别系统（Python+清新界面+数据集）

基于YOLOv5的舰船检测与识别系统（Python+清新界面+数据集）

摘要&#xff1a;基于YOLOv5的舰船检测与识别系统用于识别包括渔船、游轮等多种海上船只类型&#xff0c;检测船舰目标并进行识别计数&#xff0c;以提供海洋船只的自动化监测和管理。本文详细介绍船舰类型识别系统&#xff0c;在介绍算法原理的同时&#xff0c;给出Python的实…
阅读更多...
【系统开发】WebSocket + SpringBoot + Vue 搭建简易网页聊天室

【系统开发】WebSocket + SpringBoot + Vue 搭建简易网页聊天室

文章目录一、数据库搭建二、后端搭建2.1 引入关键依赖2.2 WebSocket配置类2.3 配置跨域2.4 发送消息的控制类三、前端搭建3.1 自定义文件websocket.js3.2 main.js中全局引入websocket3.3 App.vue中声明websocket对象3.4 聊天室界面.vue3.5 最终效果一、数据库搭建 很简单的一个…
阅读更多...
数据结构与算法——二叉树+带你实现表达式树（附源码）

数据结构与算法——二叉树+带你实现表达式树（附源码）

&#x1f4d6;作者介绍&#xff1a;22级树莓人&#xff08;计算机专业&#xff09;&#xff0c;热爱编程&#xff1c;目前在c&#xff0b;&#xff0b;阶段&#xff0c;因为最近参加新星计划算法赛道(白佬)&#xff0c;所以加快了脚步&#xff0c;果然急迫感会增加动力>——…
阅读更多...
ThreadLocal详解

ThreadLocal详解

一、什么是ThreadLocal 1、什么是ThreadLocal&为什么用ThreadLocal ThreadLocal&#xff0c;即线程本地变量&#xff0c;在类定义中的注释如此写This class provides thread-local variables。如果创建了一个ThreadLocal变量&#xff0c;那么访问这个变量的每个线程都会有…
阅读更多...
C++基础算法④——排序算法(插入、桶附完整代码)

C++基础算法④——排序算法(插入、桶附完整代码)

排序算法 1.插入排序 2.桶排序 1.插入排序 基本思想&#xff1a;将初始数据分为有序部分和无序部分&#xff1b;每一步将无序部分的第一个值插入到前面已经排好序的有序部分中&#xff0c;直到插完所有元素为止。步骤如下&#xff1a; 每次从无序部分中取出第一个值&#x…
阅读更多...
图像分类卷积神经网络模型综述

图像分类卷积神经网络模型综述

图像分类卷积神经网络模型综述遇到问题 图像分类&#xff1a;核心任务是从给定的分类集合中给图像分配一个标签任务。 输入&#xff1a;图片 输出&#xff1a;类别。 数据集MNIST数据集 MNIST数据集是用来识别手写数字&#xff0c;由0~9共10类别组成。 从MNIST数据集的SD-1和…
阅读更多...
在Clion开发工具上使用NDK编译可以在安卓上执行的程序

在Clion开发工具上使用NDK编译可以在安卓上执行的程序

1. 前言 因为工作需要&#xff0c;我要将一份C语言代码编译成可执行文件传送到某安卓系统里执行。 众所周知&#xff0c;使用ndk编译代码有三种使用方式&#xff0c;分别是基于 Make 的 ndk-build、CMake以及独立工具链。以前进行ndk编程都是使用ndk-build进行的&#xff0c;新…
阅读更多...
RocketMQ的基本概念、系统架构、单机安装与启动

RocketMQ的基本概念、系统架构、单机安装与启动

RocketMQ的基本概念、系统架构、单机安装与启动 文章目录RocketMQ的基本概念、系统架构、单机安装与启动一、基本概念1、消息&#xff08;Message&#xff09;2、主题&#xff08;Topic&#xff09;3、标签&#xff08;Tag&#xff09;4、队列&#xff08;Queue&#xff09;5、…
阅读更多...
C# 教你如何终止Task线程

C# 教你如何终止Task线程

我们在多线程中通常使用一个bool IsExit类似的代码来控制是否线程的运行与终止&#xff0c;其实使用CancellationTokenSource来进行控制更为好用&#xff0c;下面我们将介绍CancellationTokenSource相关用法。C# 使用 CancellationTokenSource 终止线程使用CancellationTokenSo…
阅读更多...
【Leetcode】-有效的括号

【Leetcode】-有效的括号

作者&#xff1a;小树苗渴望变成参天大树 作者宣言&#xff1a;认真写好每一篇博客 作者gitee:gitee 如 果 你 喜 欢 作 者 的 文 章 &#xff0c;就 给 作 者 点 点 关 注 吧&#xff01; 文章目录前言前言 今天我们再来讲一期关于题目的博客&#xff0c;我挑选的是一道leet…
阅读更多...
Git学习与gitlab中央仓库搭建（详细介绍）

Git学习与gitlab中央仓库搭建（详细介绍）

环境&#xff1a;centos7.3一&#xff0c;Git的发展史git&#xff1a;分布式版本控制系统&#xff0c;是当前最流行的版本控制软件创始人&#xff1a;林纳斯.拖瓦兹二&#xff0c;部署Git环境1.安装git服务[rootlocalhost ~]# yum -y install git2.配置git环境不一定是data目录…
阅读更多...
【C++】初识模板

【C++】初识模板

放在专栏【C知识总结】&#xff0c;会持续更新&#xff0c;期待支持&#x1f339;前言在谈及本章之前&#xff0c;我们先来聊一聊别的。橡皮泥大家小时候应该都玩过吧&#xff0c;通常我们买来的橡皮泥里面都会带有一些小动物的图案的模子。我们把橡皮泥往上面按压&#xff0c;…
阅读更多...
【性能分析】分析JVM出现的内存泄漏的性能故障

【性能分析】分析JVM出现的内存泄漏的性能故障

分析JVM出现的内存持续增加的性能故障手册 前言 本文通过常见的性能文件为例&#xff0c;提供简单清晰的思路去快速定位问题根源&#xff0c;从而可以快速解决性能故障。 性能问题介绍 在性能测试工作中针对Java程序最重要的是要关注JVM的内存消耗情况&#xff0c;JVM的内存…
阅读更多...
面试错题本

面试错题本

目录2023.3.21 深信服哈夫曼树哈夫曼编码2023.3.21 深信服 ​同一线程共享的有堆、全局变量、静态变量、指针&#xff0c;引用、文件等&#xff0c;而独自占有栈 友元函数不能被继承&#xff0c;友元函数不是成员函数 友元函数不能被继承&#xff0c;友元函数不是当前类的成员…
阅读更多...
Vue2项目总结-电商后台管理系统

Vue2项目总结-电商后台管理系统

Vue2项目总结-电商后台管理系统 去年做的项目&#xff0c;拖了很久&#xff0c;总算是打起精力去做这个项目的总结&#xff0c;并对Vue2的相关知识进行回顾与复习 各个功能模块如果有过多重复冗杂的部分&#xff0c;将会抽取部分值得记录复习的地方进行记录 一&#xff1a;项目…
阅读更多...
精心整理前端主流框架学习路径

精心整理前端主流框架学习路径

版权声明 本文原创作者&#xff1a;谷哥的小弟作者博客地址&#xff1a;http://blog.csdn.net/lfdfhl 前端主流框架 前端框架指的是用于构建Web前端应用程序的框架&#xff0c;使用框架进行前端开发带来以下显著优势&#xff1a; 提高开发效率&#xff1a;前端框架提供了现成的…
阅读更多...
最新文章

Copyright @ 2022~2023