Stream Pipelines

Stream Pipelines

首先回顧一下容器執行Lambda表達式的方式，以ArrayList.forEach()方法爲例，具體代碼如下：

// ArrayList.forEach()
public void forEach(Consumer<? super E> action) {
…
for (int i=0; modCount == expectedModCount && i < size; i++) {
action.accept(elementData[i]);// 回調方法
}
…
}
我們看到ArrayList.forEach()方法的主要邏輯就是一個for循環，在該for循環裏不斷調用action.accept()回調方法完成對元素的遍歷。這完全沒有什麼新奇之處，回調方法在Java GUI的監聽器中廣泛使用。Lambda表達式的作用就是相當於一個回調方法，這很好理解。

Stream API中大量使用Lambda表達式作爲回調方法，但這並不是關鍵。理解Stream我們更關心的是另外兩個問題：流水線和自動並行。使用Stream或許很容易寫入如下形式的代碼：

int longestStringLengthStartingWithA
= strings.stream()
.filter(s -> s.startsWith(“A”))
.mapToInt(String::length)
.max();
上述代碼求出以字母A開頭的字符串的最大長度，一種直白的方式是爲每一次函數調用都執一次迭代，這樣做能夠實現功能，但效率上肯定是無法接受的。類庫的實現着使用流水線（Pipeline）的方式巧妙的避免了多次迭代，其基本思想是在一次迭代中儘可能多的執行用戶指定的操作。爲講解方便我們彙總了Stream的所有操作。

Stream操作分類
中間操作(Intermediate operations) 無狀態(Stateless) unordered() filter() map() mapToInt() mapToLong() mapToDouble() flatMap() flatMapToInt() flatMapToLong() flatMapToDouble() peek()
有狀態(Stateful) distinct() sorted() sorted() limit() skip()
結束操作(Terminal operations) 非短路操作 forEach() forEachOrdered() toArray() reduce() collect() max() min() count()
短路操作(short-circuiting) anyMatch() allMatch() noneMatch() findFirst() findAny()
Stream上的所有操作分爲兩類：中間操作和結束操作，中間操作只是一種標記，只有結束操作纔會觸發實際計算。中間操作又可以分爲無狀態的(Stateless)和有狀態的(Stateful)，無狀態中間操作是指元素的處理不受前面元素的影響，而有狀態的中間操作必須等到所有元素處理之後才知道最終結果，比如排序是有狀態操作，在讀取所有元素之前並不能確定排序結果；結束操作又可以分爲短路操作和非短路操作，短路操作是指不用處理全部元素就可以返回結果，比如找到第一個滿足條件的元素。之所以要進行如此精細的劃分，是因爲底層對每一種情況的處理方式不同。 爲了更好的理解流的中間操作和終端操作，可以通過下面的兩段代碼來看他們的執行過程。

IntStream.range(1, 10)
.peek(x -> System.out.print("\nA" + x))
.limit(3)
.peek(x -> System.out.print(“B” + x))
.forEach(x -> System.out.print(“C” + x));
輸出爲： A1B1C1 A2B2C2 A3B3C3 中間操作是懶惰的，也就是中間操作不會對數據做任何操作，直到遇到了最終操作。而最終操作，都是比較熱情的。他們會往前回溯所有的中間操作。也就是當執行到最後的forEach操作的時候，它會回溯到它的上一步中間操作，上一步中間操作，又會回溯到上上一步的中間操作，…，直到最初的第一步。 第一次forEach執行的時候，會回溯peek 操作，然後peek會回溯更上一步的limit操作，然後limit會回溯更上一步的peek操作，頂層沒有操作了，開始自上向下開始執行，輸出：A1B1C1 第二次forEach執行的時候，然後會回溯peek 操作，然後peek會回溯更上一步的limit操作，然後limit會回溯更上一步的peek操作，頂層沒有操作了，開始自上向下開始執行，輸出：A2B2C2

… 當第四次forEach執行的時候，然後會回溯peek 操作，然後peek會回溯更上一步的limit操作，到limit的時候，發現limit(3)這個job已經完成，這裏就相當於循環裏面的break操作，跳出來終止循環。

再來看第二段代碼：

IntStream.range(1, 10)
.peek(x -> System.out.print("\nA" + x))
.skip(6)
.peek(x -> System.out.print(“B” + x))
.forEach(x -> System.out.print(“C” + x));
輸出爲： A1 A2 A3 A4 A5 A6 A7B7C7 A8B8C8 A9B9C9 第一次forEach執行的時候，會回溯peek操作，然後peek會回溯更上一步的skip操作，skip回溯到上一步的peek操作，頂層沒有操作了，開始自上向下開始執行，執行到skip的時候，因爲執行到skip，這個操作的意思就是跳過，下面的都不要執行了，也就是就相當於循環裏面的continue，結束本次循環。輸出：A1

第二次forEach執行的時候，會回溯peek操作，然後peek會回溯更上一步的skip操作，skip回溯到上一步的peek操作，頂層沒有操作了，開始自上向下開始執行，執行到skip的時候，發現這是第二次skip，結束本次循環。輸出：A2

…

第七次forEach執行的時候，會回溯peek操作，然後peek會回溯更上一步的skip操作，skip回溯到上一步的peek操作，頂層沒有操作了，開始自上向下開始執行，執行到skip的時候，發現這是第七次skip，已經大於6了，它已經執行完了skip(6)的job了。這次skip就直接跳過，繼續執行下面的操作。輸出：A7B7C7

…直到循環結束。

一種直白的實現方式
Stream_pipeline_naive

仍然考慮上述求最長字符串的程序，一種直白的流水線實現方式是爲每一次函數調用都執一次迭代，並將處理中間結果放到某種數據結構中（比如數組，容器等）。具體說來，就是調用filter()方法後立即執行，選出所有以A開頭的字符串並放到一個列表list1中，之後讓list1傳遞給mapToInt()方法並立即執行，生成的結果放到list2中，最後遍歷list2找出最大的數字作爲最終結果。程序的執行流程如如所示：

這樣做實現起來非常簡單直觀，但有兩個明顯的弊端：

迭代次數多。迭代次數跟函數調用的次數相等。
頻繁產生中間結果。每次函數調用都產生一次中間結果，存儲開銷無法接受。
這些弊端使得效率底下，根本無法接受。如果不使用Stream API我們都知道上述代碼該如何在一次迭代中完成，大致是如下形式：

int longest = 0;
for(String str : strings){
if(str.startsWith(“A”)){// 1. filter(), 保留以A開頭的字符串
int len = str.length();// 2. mapToInt(), 轉換成長度
longest = Math.max(len, longest);// 3. max(), 保留最長的長度
}
}
採用這種方式我們不但減少了迭代次數，也避免了存儲中間結果，顯然這就是流水線，因爲我們把三個操作放在了一次迭代當中。只要我們事先知道用戶意圖，總是能夠採用上述方式實現跟Stream API等價的功能，但問題是Stream類庫的設計者並不知道用戶的意圖是什麼。如何在無法假設用戶行爲的前提下實現流水線，是類庫的設計者要考慮的問題。

Stream流水線解決方案
我們大致能夠想到，應該採用某種方式記錄用戶每一步的操作，當用戶調用結束操作時將之前記錄的操作疊加到一起在一次迭代中全部執行掉。沿着這個思路，有幾個問題需要解決：

用戶的操作如何記錄？
操作如何疊加？
疊加之後的操作如何執行？
執行後的結果（如果有）在哪裏？

操作如何記錄
Java_stream_pipeline_classes

注意這裏使用的是“操作(operation)”一詞，指的是“Stream中間操作”的操作，很多Stream操作會需要一個回調函數（Lambda表達式），因此一個完整的操作是<數據來源，操作，回調函數>構成的三元組。Stream中使用Stage的概念來描述一個完整的操作，並用某種實例化後的PipelineHelper來代表Stage，將具有先後順序的各個Stage連到一起，就構成了整個流水線。跟Stream相關類和接口的繼承關係圖示。

還有IntPipeline, LongPipeline, DoublePipeline沒在圖中畫出，這三個類專門爲三種基本類型（不是包裝類型）而定製的，跟ReferencePipeline是並列關係。圖中Head用於表示第一個Stage，即調用調用諸如Collection.stream()方法產生的Stage，很顯然這個Stage裏不包含任何操作；StatelessOp和StatefulOp分別表示無狀態和有狀態的Stage，對應於無狀態和有狀態的中間操作。

Stream流水線組織結構示意圖如下：

Stream_pipeline_example

圖中通過Collection.stream()方法得到Head也就是stage0，緊接着調用一系列的中間操作，不斷產生新的Stream。這些Stream對象以雙向鏈表的形式組織在一起，構成整個流水線，由於每個Stage都記錄了前一個Stage和本次的操作以及回調函數，依靠這種結構就能建立起對數據源的所有操作。這就是Stream記錄操作的方式。

操作如何疊加
以上只是解決了操作記錄的問題，要想讓流水線起到應有的作用我們需要一種將所有操作疊加到一起的方案。你可能會覺得這很簡單，只需要從流水線的head開始依次執行每一步的操作（包括回調函數）就行了。這聽起來似乎是可行的，但是你忽略了前面的Stage並不知道後面Stage到底執行了哪種操作，以及回調函數是哪種形式。換句話說，只有當前Stage本身才知道該如何執行自己包含的動作。這就需要有某種協議來協調相鄰Stage之間的調用關係。

這種協議由Sink接口完成，Sink接口包含的方法如下表所示：

方法名 作用
void begin(long size) 開始遍歷元素之前調用該方法，通知Sink做好準備。
void end() 所有元素遍歷完成之後調用，通知Sink沒有更多的元素了。
boolean cancellationRequested() 是否可以結束操作，可以讓短路操作儘早結束。
void accept(T t) 遍歷元素時調用，接受一個待處理元素，並對元素進行處理。Stage把自己包含的操作和回調方法封裝到該方法裏，前一個Stage只需要調用當前Stage.accept(T t)方法就行了。
有了上面的協議，相鄰Stage之間調用就很方便了，每個Stage都會將自己的操作封裝到一個Sink裏，前一個Stage只需調用後一個Stage的accept()方法即可，並不需要知道其內部是如何處理的。當然對於有狀態的操作，Sink的begin()和end()方法也是必須實現的。比如Stream.sorted()是一個有狀態的中間操作，其對應的Sink.begin()方法可能創建一個盛放結果的容器，而accept()方法負責將元素添加到該容器，最後end()負責對容器進行排序。對於短路操作，Sink.cancellationRequested()也是必須實現的，比如Stream.findFirst()是短路操作，只要找到一個元素，cancellationRequested()就應該返回true，以便調用者儘快結束查找。Sink的四個接口方法常常相互協作，共同完成計算任務。實際上Stream API內部實現的的本質，就是如何重寫Sink的這四個接口方法。

有了Sink對操作的包裝，Stage之間的調用問題就解決了，執行時只需要從流水線的head開始對數據源依次調用每個Stage對應的Sink.{begin(), accept(), cancellationRequested(), end()}方法就可以了。一種可能的Sink.accept()方法流程是這樣的：

void accept(U u){
1. 使用當前Sink包裝的回調函數處理u
2. 將處理結果傳遞給流水線下游的Sink
}
Sink接口的其他幾個方法也是按照這種[處理->轉發]的模型實現。下面我們結合具體例子看看Stream的中間操作是如何將自身的操作包裝成Sink以及Sink是如何將處理結果轉發給下一個Sink的。先看Stream.map()方法：

// Stream.map()，調用該方法將產生一個新的Stream
public final Stream map(Function<? super P_OUT, ? extends R> mapper) {
…
return new StatelessOp<P_OUT, R>(this, StreamShape.REFERENCE,
StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
@Override /opWripSink()方法返回由回調函數包裝而成Sink/
Sink<P_OUT> opWrapSink(int flags, Sink downstream) {
return new Sink.ChainedReference<P_OUT, R>(downstream) {
@Override
public void accept(P_OUT u) {
R r = mapper.apply(u);// 1. 使用當前Sink包裝的回調函數mapper處理u
downstream.accept®;// 2. 將處理結果傳遞給流水線下游的Sink
}
};
}
};
}
上述代碼看似複雜，其實邏輯很簡單，就是將回調函數mapper包裝到一個Sink當中。由於Stream.map()是一個無狀態的中間操作，所以map()方法返回了一個StatelessOp內部類對象（一個新的Stream），調用這個新Stream的opWripSink()方法將得到一個包裝了當前回調函數的Sink。

再來看一個複雜一點的例子。Stream.sorted()方法將對Stream中的元素進行排序，顯然這是一個有狀態的中間操作，因爲讀取所有元素之前是沒法得到最終順序的。拋開模板代碼直接進入問題本質，sorted()方法是如何將操作封裝成Sink的呢？sorted()一種可能封裝的Sink代碼如下：

// Stream.sort()方法用到的Sink實現
class RefSortingSink extends AbstractRefSortingSink {
private ArrayList list;// 存放用於排序的元素
RefSortingSink(Sink<? super T> downstream, Comparator<? super T> comparator) {
super(downstream, comparator);
}
@Override
public void begin(long size) {
…
// 創建一個存放排序元素的列表
list = (size >= 0) ? new ArrayList((int) size) : new ArrayList();
}
@Override
public void end() {
list.sort(comparator);// 只有元素全部接收之後才能開始排序
downstream.begin(list.size());
if (!cancellationWasRequested) {// 下游Sink不包含短路操作
list.forEach(downstream::accept);// 2. 將處理結果傳遞給流水線下游的Sink
}
else {// 下游Sink包含短路操作
for (T t : list) {// 每次都調用cancellationRequested()詢問是否可以結束處理。
if (downstream.cancellationRequested()) break;
downstream.accept(t);// 2. 將處理結果傳遞給流水線下游的Sink
}
}
downstream.end();
list = null;
}
@Override
public void accept(T t) {
list.add(t);// 1. 使用當前Sink包裝動作處理t，只是簡單的將元素添加到中間列表當中
}
}
上述代碼完美的展現了Sink的四個接口方法是如何協同工作的：

首先begin()方法告訴Sink參與排序的元素個數，方便確定中間結果容器的的大小；
之後通過accept()方法將元素添加到中間結果當中，最終執行時調用者會不斷調用該方法，直到遍歷所有元素；
最後end()方法告訴Sink所有元素遍歷完畢，啓動排序步驟，排序完成後將結果傳遞給下游的Sink；
如果下游的Sink是短路操作，將結果傳遞給下游時不斷詢問下游cancellationRequested()是否可以結束處理。

疊加之後的操作如何執行
Stream_pipeline_Sink

Sink完美封裝了Stream每一步操作，並給出了[處理->轉發]的模式來疊加操作。這一連串的齒輪已經咬合，就差最後一步撥動齒輪啓動執行。是什麼啓動這一連串的操作呢？也許你已經想到了啓動的原始動力就是結束操作(Terminal Operation)，一旦調用某個結束操作，就會觸發整個流水線的執行。

結束操作之後不能再有別的操作，所以結束操作不會創建新的流水線階段(Stage)，直觀的說就是流水線的鏈表不會在往後延伸了。結束操作會創建一個包裝了自己操作的Sink，這也是流水線中最後一個Sink，這個Sink只需要處理數據而不需要將結果傳遞給下游的Sink（因爲沒有下游）。對於Sink的[處理->轉發]模型，結束操作的Sink就是調用鏈的出口。

我們再來考察一下上游的Sink是如何找到下游Sink的。一種可選的方案是在PipelineHelper中設置一個Sink字段，在流水線中找到下游Stage並訪問Sink字段即可。但Stream類庫的設計者沒有這麼做，而是設置了一個Sink AbstractPipeline.opWrapSink(int flags, Sink downstream)方法來得到Sink，該方法的作用是返回一個新的包含了當前Stage代表的操作以及能夠將結果傳遞給downstream的Sink對象。爲什麼要產生一個新對象而不是返回一個Sink字段？這是因爲使用opWrapSink()可以將當前操作與下游Sink（上文中的downstream參數）結合成新Sink。試想只要從流水線的最後一個Stage開始，不斷調用上一個Stage的opWrapSink()方法直到最開始（不包括stage0，因爲stage0代表數據源，不包含操作），就可以得到一個代表了流水線上所有操作的Sink，用代碼表示就是這樣：

// AbstractPipeline.wrapSink()
// 從下游向上遊不斷包裝Sink。如果最初傳入的sink代表結束操作，
// 函數返回時就可以得到一個代表了流水線上所有操作的Sink。
final <P_IN> Sink<P_IN> wrapSink(Sink<E_OUT> sink) {
…
for (AbstractPipeline p=AbstractPipeline.this; p.depth > 0; p=p.previousStage) {
sink = p.opWrapSink(p.previousStage.combinedFlags, sink);
}
return (Sink<P_IN>) sink;
}
現在流水線上從開始到結束的所有的操作都被包裝到了一個Sink裏，執行這個Sink就相當於執行整個流水線，執行Sink的代碼如下：

// AbstractPipeline.copyInto(), 對spliterator代表的數據執行wrappedSink代表的操作。
final <P_IN> void copyInto(Sink<P_IN> wrappedSink, Spliterator<P_IN> spliterator) {
…
if (!StreamOpFlag.SHORT_CIRCUIT.isKnown(getStreamAndOpFlags())) {
wrappedSink.begin(spliterator.getExactSizeIfKnown());// 通知開始遍歷
spliterator.forEachRemaining(wrappedSink);// 迭代
wrappedSink.end();// 通知遍歷結束
}
…
}
上述代碼首先調用wrappedSink.begin()方法告訴Sink數據即將到來，然後調用spliterator.forEachRemaining()方法對數據進行迭代（Spliterator是容器的一種迭代器，參閱），最後調用wrappedSink.end()方法通知Sink數據處理結束。邏輯如此清晰。

執行後的結果在哪裏
最後一個問題是流水線上所有操作都執行後，用戶所需要的結果（如果有）在哪裏？首先要說明的是不是所有的Stream結束操作都需要返回結果，有些操作只是爲了使用其副作用(Side-effects)，比如使用Stream.forEach()方法將結果打印出來就是常見的使用副作用的場景（事實上，除了打印之外其他場景都應避免使用副作用），對於真正需要返回結果的結束操作結果存在哪裏呢？

特別說明：副作用不應該被濫用，也許你會覺得在Stream.forEach()裏進行元素收集是個不錯的選擇，就像下面代碼中那樣，但遺憾的是這樣使用的正確性和效率都無法保證，因爲Stream可能會並行執行。大多數使用副作用的地方都可以使用歸約操作更安全和有效的完成。

// 錯誤的收集方式
ArrayList results = new ArrayList<>();
stream.filter(s -> pattern.matcher(s).matches())
.forEach(s -> results.add(s)); // Unnecessary use of side-effects!
// 正確的收集方式
Listresults =
stream.filter(s -> pattern.matcher(s).matches())
.collect(Collectors.toList()); // No side-effects!
回到流水線執行結果的問題上來，需要返回結果的流水線結果存在哪裏呢？這要分不同的情況討論，下表給出了各種有返回結果的Stream結束操作。

返回類型 對應的結束操作
boolean anyMatch() allMatch() noneMatch()
Optional findFirst() findAny()
歸約結果 reduce() collect()
數組 toArray()
對於表中返回boolean或者Optional的操作（Optional是存放 一個 值的容器）的操作，由於值返回一個值，只需要在對應的Sink中記錄這個值，等到執行結束時返回就可以了。
對於歸約操作，最終結果放在用戶調用時指定的容器中（容器類型通過收集器指定）。collect(), reduce(), max(), min()都是歸約操作，雖然max()和min()也是返回一個Optional，但事實上底層是通過調用reduce()方法實現的。
對於返回是數組的情況，毫無疑問的結果會放在數組當中。這麼說當然是對的，但在最終返回數組之前，結果其實是存儲在一種叫做Node的數據結構中的。Node是一種多叉樹結構，元素存儲在樹的葉子當中，並且一個葉子節點可以存放多個元素。這樣做是爲了並行執行方便。
git地址：Stream Pipelines