Java8中流的性能及流的几个特性
摘要：本文介绍了Java8中流的几个特性，以告诫开发者流并不是高性能的代名词，需谨慎使用流。以下是译文。
流（Stream）是Java8为了实现最佳性能而引入的一个全新的概念。在过去的几年中，随着硬件的持续发展，编程方式已经发生了巨大的改变，程序的性能也随着并行处理、实时、云和其他一些编程方法的出现而得到了不断提高。
Java8中，流性能的提升是通过并行化（parallelism）、惰性（Laziness）和短路操作（short-circuit operations）来实现的。但它也有一个缺点，在选择流的时候需要非常小心，因为这可能会降低应用程序的性能。
下面来看看这三项支撑起流强大性能的因素吧。
并行化
流的并行化充分利用了硬件的相关功能。由于现在计算机上通常都有多个CPU核心，所以在多核系统中如果只使用一个线程则会极大地浪费系统资源。设计和编写多线程应用非常具有挑战性，并且很容易出错，因此，流存在两种实现：顺序和并行。使用并行流非常简单，无需专业知识即可轻松处理多线程问题。
在Java的流中，并行化是通过Fork-Join原理来实现的。根据Fork-Join原理，系统会将较大的任务切分成较小的子任务（称之为forking），然后并行处理这些子任务以充分利用所有可用的硬件资源，最后将结果合并起来（称之为Join）组成完整的结果。
在选择顺序和并行的时候，需要非常谨慎，因为并行并一定意味着性能会更好。
让我们来看一个例子。
StreamTest.java:
package test;
import java.util.ArrayList;
import java.util.List;
public class StreamTest {
static List < Integer > myList = new ArrayList < > ();
public static void main(String[] args) {
for (int i = 0; i < 5000000; i++)
myList.add(i);
int result = 0;
long loopStartTime = System.currentTimeMillis();
for (int i: myList) {
if (i % 2 == 0)
result += i;
}
long loopEndTime = System.currentTimeMillis();
System.out.println(result);
System.out.println("Loop total Time = " + (loopEndTime - loopStartTime));
long streamStartTime = System.currentTimeMillis();
System.out.println(myList.stream().filter(value -> value % 2 == 0).mapToInt(Integer::intValue).sum());
long streamEndTime = System.currentTimeMillis();
System.out.println("Stream total Time = " + (streamEndTime - streamStartTime));
long parallelStreamStartTime = System.currentTimeMillis();
System.out.println(myList.parallelStream().filter(value -> value % 2 == 0).mapToInt(Integer::intValue).sum());
long parallelStreamEndTime = System.currentTimeMillis();
System.out.println("Parallel Stream total Time = " + (parallelStreamEndTime - parallelStreamStartTime));
}
}
运行结果：
820084320 Loop total Time = 17 820084320 Stream total Time = 81 820084320 Parallel Stream total Time = 30
正如你所见，在这种情况下，for循环更好。因此，在没有正确的分析之前，不要用流代替for循环。在这里，我们可以看到，并行流的性能比普通流更好。
注意：结果可能会因为硬件的不同而不同。
惰性
我们知道，Java8的流有两种类型的操作，分别为中间操作（Intermediate）和最终操作（Terminal）。这两种操作分别用于处理和提供最终结果。如果最终操作不与中间操作相关联，则无法执行。
总之，中间操作只是创建另一个流，不会执行任何处理，直到最终操作被调用。一旦最终操作被调用，则开始遍历所有的流，并且相关的函数会逐一应用到流上。中间操作是惰性操作，所以，流支持惰性。
注意：对于并行流，并不会在最后逐个遍历流，而是并行处理流，并且并行度取决于机器CPU核心的个数。
考虑一下这种情况，假设我们有一个只有中间操作的流片段，而最终操作要稍后才会添加到应用中（可能需要也可能不需要，取决于用户的需求）。在这种情况下，流的中间操作将会为最终操作创建另一个流，但不会执行实际的处理。这种机制有助于提高性能。
我们来看一下有关惰性的例子：
StreamLazinessTest.java:
package test;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class StreamLazinessTest {
/** Employee class **/
static class Employee {
int id;
String name;
public Employee(int id, String name) {
this.id = id;
this.name = name;
}
public String getName() {
return this.name;
}
}
public static void main(String[] args) throws InterruptedException {
List < Employee > employees = new ArrayList < > ();
/** Creating the employee list **/
for (int i = 1; i < 10000000; i++) {
employees.add(new StreamLazinessTest.Employee(i, "name_" + i));
}
/** Only Intermediate Operations; it will just create another streams and
* will not perform any operations **/
Stream < String > employeeNameStreams = employees.parallelStream().filter(employee -> employee.id % 2 == 0)
.map(employee -> {
System.out.println("In Map - " + employee.getName());
return employee.getName();
});
/** Adding some delay to make sure nothing has happen till now **/
Thread.sleep(2000);
System.out.println("2 sec");
/** Terminal operation on the stream and it will invoke the Intermediate Operations
* filter and map **/
employeeNameStreams.collect(Collectors.toList());
}
}
运行上面的代码，你可以看到在调用最前操作之前，中间操作不会被执行。
短路行为
这是优化流处理的另一种方法。 一旦条件满足，短路操作将会终止处理过程。 有许多短路操作可供使用。 例如，anyMatch、allMatch、findFirst、findAny、limit等等。
我们来看一个例子。
StreamShortCircuitTest.java:
package test;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class StreamShortCircuitTest {
/** Employee class **/
static class Employee {
int id;
String name;
public Employee(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return this.id;
}
public String getName() {
return this.name;
}
}
public static void main(String[] args) throws InterruptedException {
List < Employee > employees = new ArrayList < > ();
for (int i = 1; i < 10000000; i++) {
employees.add(new StreamShortCircuitTest.Employee(i, "name_" + i));
}
/** Only Intermediate Operations; it will just create another streams and
* will not perform any operations **/
Stream < String > employeeNameStreams = employees.stream().filter(e -> e.getId() % 2 == 0)
.map(employee -> {
System.out.println("In Map - " + employee.getName());
return employee.getName();
});
long streamStartTime = System.currentTimeMillis();
/** Terminal operation with short-circuit operation: limit **/
employeeNameStreams.limit(100).collect(Collectors.toList());
System.out.println(System.currentTimeMillis() - streamStartTime);
}
}
运行上面的代码，你会看到性能得到了极大地提升，在我的机器上只需要6毫秒的时间。 在这里，limit()方法在满足条件的时候会中断运行。
最后要注意的是，根据状态的不同有两种类型的中间操作：有状态（Stateful）和无状态（Stateless）中间操作。
有状态中间操作
这些中间操作需要存储状态，因此可能会导致应用程序的性能下降，例如，distinct()、sort()、limit()等等。
无状态中间操作
这些中间操作可以独立处理，因为它们不需要保存状态，例如， filter()，map()等。
在这里，我们了解到，流的出现是为了获得更高的性能，但并不是说使用了流之后性能肯定会得到提升，因此，我们需要谨慎使用。
总结
以上所述是小编给大家介绍的Java8中流的性能及流的几个特性，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对脚本之家网站的支持！
相关文章
汉诺塔问题是一个经典的问题。汉诺塔（Hanoi Tower），又称河内塔，源于印度一个古老传说。本文将用Java SE求解这一问题，感兴趣的可以学习一下2022-03-03
这篇文章主要介绍了解决 Spring Boot 端口被占用的方法详解，通过本文的介绍，你学习了如何解决 Spring Boot 端口被占用的问题。你了解了检查端口是否被占用、停止占用端口的进程、更改应用程序的端口号以及检查应用程序间的端口冲突等方法,需要的朋友可以参考下2023-07-07
我们在编写代码时，常常会遇到代码又长又重复的情况，就像调用第3方服务时，每个方法都差不多, 写起来啰嗦, 改起来麻烦, 还容易改漏，所以本文就来用Lambda表达式简化一下代码，希望对大家有所帮助2023-05-05
这篇文章主要介绍了mybatis中的mapper.xml使用循环语句，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2022-02-02
Spring框架是一个开放源代码的J2EE应用程序框架，是针对bean的生命周期进行管理的轻量级容Spring解决了开发者在J2EE开发中遇到的许多常见的问题，我们这篇文章就来了解一下spring的面试题2021-06-06
这篇文章主要介绍了Springboot文件上传功能简单测试,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下2020-05-05
这篇文章主要介绍了Java编程基于快速排序的三个算法题实例代码，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下2018-01-01
这篇文章主要介绍了Spring启动流程源码解析,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2024-07-07
Java/Web调用Hadoop进行MapReduce示例代码
本篇文章主要介绍了Java/Web调用Hadoop进行MapReduce示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧2017-11-11
GSON是谷歌在GitHub上开源的Java的JSON格式转换类库,能够实现Java对象向JSON的序列和反序列,这里我们就来举例讲解Java的JSON类库GSON的基本用法:2016-06-06
最新评论