摘要：本文介紹了Java8中流的幾個特性，以告誡開發者流并不是高性能的代名詞，需謹慎使用流。以下是譯文。
流（Stream）是Java8為了實現最佳性能而引入的一個全新的概念。在過去的幾年中，隨著硬件的持續發展，編程方式已經發生了巨大的改變，程序的性能也隨著并行處理、實時、云和其他一些編程方法的出現而得到了不斷提高。
Java8中，流性能的提升是通過并行化（parallelism）、惰性（Laziness）和短路操作（short-circuit operations）來實現的。但它也有一個缺點，在選擇流的時候需要非常小心，因為這可能會降低應用程序的性能。
下面來看看這三項支撐起流強大性能的因素吧。
并行化
流的并行化充分利用了硬件的相關功能。由于現在計算機上通常都有多個CPU核心，所以在多核系統中如果只使用一個線程則會極大地浪費系統資源。設計和編寫多線程應用非常具有挑戰性，并且很容易出錯，因此，流存在兩種實現：順序和并行。使用并行流非常簡單，無需專業知識即可輕松處理多線程問題。
在Java的流中，并行化是通過Fork-Join原理來實現的。根據Fork-Join原理，系統會將較大的任務切分成較小的子任務（稱之為forking），然后并行處理這些子任務以充分利用所有可用的硬件資源，最后將結果合并起來（稱之為Join）組成完整的結果。
在選擇順序和并行的時候，需要非常謹慎，因為并行并一定意味著性能會更好。
讓我們來看一個例子。
StreamTest.java:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
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)); }} |
運行結果：
|
1
2
3
4
5
6
|
820084320Loop total Time = 17820084320Stream total Time = 81820084320Parallel Stream total Time = 30 |
正如你所見，在這種情況下，for循環更好。因此，在沒有正確的分析之前，不要用流代替for循環。在這里，我們可以看到，并行流的性能比普通流更好。
注意：結果可能會因為硬件的不同而不同。
惰性
我們知道，Java8的流有兩種類型的操作，分別為中間操作（Intermediate）和最終操作（Terminal）。這兩種操作分別用于處理和提供最終結果。如果最終操作不與中間操作相關聯，則無法執行。
總之，中間操作只是創建另一個流，不會執行任何處理，直到最終操作被調用。一旦最終操作被調用，則開始遍歷所有的流，并且相關的函數會逐一應用到流上。中間操作是惰性操作，所以，流支持惰性。
注意：對于并行流，并不會在最后逐個遍歷流，而是并行處理流，并且并行度取決于機器CPU核心的個數。
考慮一下這種情況，假設我們有一個只有中間操作的流片段，而最終操作要稍后才會添加到應用中（可能需要也可能不需要，取決于用戶的需求）。在這種情況下，流的中間操作將會為最終操作創建另一個流，但不會執行實際的處理。這種機制有助于提高性能。
我們來看一下有關惰性的例子：
StreamLazinessTest.java:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
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等等。
我們來看一個例子。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
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中流的性能及流的幾個特性，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對服務器之家網站的支持！
原文鏈接：http://blog.csdn.net/dev_csdn/article/details/78491351?utm_source=tuicool&utm_medium=referral
