快捷導(dǎo)航

Java8中流的性能及流的幾個(gè)特性

更新時(shí)間：2017年11月13日 16:50:22 投稿：mrr

流（Stream）是Java8為了實(shí)現(xiàn)最佳性能而引入的一個(gè)全新的概念。接下來(lái)通過(guò)本文給大家分享Java8中流的性能，需要的朋友參考下吧

摘要：本文介紹了Java8中流的幾個(gè)特性，以告誡開(kāi)發(fā)者流并不是高性能的代名詞，需謹(jǐn)慎使用流。以下是譯文。

流（Stream）是Java8為了實(shí)現(xiàn)最佳性能而引入的一個(gè)全新的概念。在過(guò)去的幾年中，隨著硬件的持續(xù)發(fā)展，編程方式已經(jīng)發(fā)生了巨大的改變，程序的性能也隨著并行處理、實(shí)時(shí)、云和其他一些編程方法的出現(xiàn)而得到了不斷提高。

Java8中，流性能的提升是通過(guò)并行化（parallelism）、惰性（Laziness）和短路操作（short-circuit operations）來(lái)實(shí)現(xiàn)的。但它也有一個(gè)缺點(diǎn)，在選擇流的時(shí)候需要非常小心，因?yàn)檫@可能會(huì)降低應(yīng)用程序的性能。

下面來(lái)看看這三項(xiàng)支撐起流強(qiáng)大性能的因素吧。

并行化

流的并行化充分利用了硬件的相關(guān)功能。由于現(xiàn)在計(jì)算機(jī)上通常都有多個(gè)CPU核心，所以在多核系統(tǒng)中如果只使用一個(gè)線程則會(huì)極大地浪費(fèi)系統(tǒng)資源。設(shè)計(jì)和編寫(xiě)多線程應(yīng)用非常具有挑戰(zhàn)性，并且很容易出錯(cuò)，因此，流存在兩種實(shí)現(xiàn)：順序和并行。使用并行流非常簡(jiǎn)單，無(wú)需專業(yè)知識(shí)即可輕松處理多線程問(wèn)題。

在Java的流中，并行化是通過(guò)Fork-Join原理來(lái)實(shí)現(xiàn)的。根據(jù)Fork-Join原理，系統(tǒng)會(huì)將較大的任務(wù)切分成較小的子任務(wù)（稱之為forking），然后并行處理這些子任務(wù)以充分利用所有可用的硬件資源，最后將結(jié)果合并起來(lái)（稱之為Join）組成完整的結(jié)果。

在選擇順序和并行的時(shí)候，需要非常謹(jǐn)慎，因?yàn)椴⑿胁⒁欢ㄒ馕吨阅軙?huì)更好。

讓我們來(lái)看一個(gè)例子。

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));
 }
}

運(yùn)行結(jié)果：

820084320
Loop total Time = 17
820084320
Stream total Time = 81
820084320
Parallel Stream total Time = 30

正如你所見(jiàn)，在這種情況下，for循環(huán)更好。因此，在沒(méi)有正確的分析之前，不要用流代替for循環(huán)。在這里，我們可以看到，并行流的性能比普通流更好。

注意：結(jié)果可能會(huì)因?yàn)橛布牟煌煌?/span>

惰性

我們知道，Java8的流有兩種類型的操作，分別為中間操作（Intermediate）和最終操作（Terminal）。這兩種操作分別用于處理和提供最終結(jié)果。如果最終操作不與中間操作相關(guān)聯(lián)，則無(wú)法執(zhí)行。

總之，中間操作只是創(chuàng)建另一個(gè)流，不會(huì)執(zhí)行任何處理，直到最終操作被調(diào)用。一旦最終操作被調(diào)用，則開(kāi)始遍歷所有的流，并且相關(guān)的函數(shù)會(huì)逐一應(yīng)用到流上。中間操作是惰性操作，所以，流支持惰性。

注意：對(duì)于并行流，并不會(huì)在最后逐個(gè)遍歷流，而是并行處理流，并且并行度取決于機(jī)器CPU核心的個(gè)數(shù)。

考慮一下這種情況，假設(shè)我們有一個(gè)只有中間操作的流片段，而最終操作要稍后才會(huì)添加到應(yīng)用中（可能需要也可能不需要，取決于用戶的需求）。在這種情況下，流的中間操作將會(huì)為最終操作創(chuàng)建另一個(gè)流，但不會(huì)執(zhí)行實(shí)際的處理。這種機(jī)制有助于提高性能。

我們來(lái)看一下有關(guān)惰性的例子：

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());
 }
}

運(yùn)行上面的代碼，你可以看到在調(diào)用最前操作之前，中間操作不會(huì)被執(zhí)行。

短路行為

這是優(yōu)化流處理的另一種方法。一旦條件滿足，短路操作將會(huì)終止處理過(guò)程。有許多短路操作可供使用。例如，anyMatch、allMatch、findFirst、findAny、limit等等。

我們來(lái)看一個(gè)例子。

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);
 }
}

運(yùn)行上面的代碼，你會(huì)看到性能得到了極大地提升，在我的機(jī)器上只需要6毫秒的時(shí)間。在這里，limit()方法在滿足條件的時(shí)候會(huì)中斷運(yùn)行。

最后要注意的是，根據(jù)狀態(tài)的不同有兩種類型的中間操作：有狀態(tài)（Stateful）和無(wú)狀態(tài)（Stateless）中間操作。

有狀態(tài)中間操作

這些中間操作需要存儲(chǔ)狀態(tài)，因此可能會(huì)導(dǎo)致應(yīng)用程序的性能下降，例如，distinct()、sort()、limit()等等。

無(wú)狀態(tài)中間操作

這些中間操作可以獨(dú)立處理，因?yàn)樗鼈儾恍枰４鏍顟B(tài)，例如， filter()，map()等。

在這里，我們了解到，流的出現(xiàn)是為了獲得更高的性能，但并不是說(shuō)使用了流之后性能肯定會(huì)得到提升，因此，我們需要謹(jǐn)慎使用。

總結(jié)

以上所述是小編給大家介紹的Java8中流的性能及流的幾個(gè)特性，希望對(duì)大家有所幫助，如果大家有任何疑問(wèn)請(qǐng)給我留言，小編會(huì)及時(shí)回復(fù)大家的。在此也非常感謝大家對(duì)腳本之家網(wǎng)站的支持！

您可能感興趣的文章: