文章目录

• 操作符的分类
• 流水线的结构
• AbstractPipeline
• Stream的生成源码分析
• 添加中间操作
• 万事俱备，只欠东风

上一篇文章中大体的介绍了Stream的概念和基本API的使用，Stream用起来的确非常的爽。这一篇文章将会讲述Stream的底层实现原理。

操作符的分类

Stream中的操作可以分为两大类：中间操作与结束操作，中间操作只是对操作进行了记录，只有结束操作才会触发实际的计算（即惰性求值），这也是Stream在迭代大集合时高效的原因之一。
中间操作又可以分为无状态（Stateless）操作与有状态（Stateful）操作，前者是指元素的处理不受之前元素的影响；后者是指该操作只有拿到所有元素之后才能继续下去。
结束操作又可以分为短路与非短路操作，这个应该很好理解，前者是指遇到某些符合条件的元素就可以得到最终结果；而后者是指必须处理所有元素才能得到最终结果。

流水线的结构

Stream的主要接口类的关系如下图：

类关系图

• BaseStream规定了流的基本接口
• Stream中定义了map、filter、flatmap等用户关注的常用操作；
• Int~ Long~ Double~是针对于基本类型的特化 方法与Stream中大致对应,当然也有一些差别
• BaseStream Stream IntStream LongStream DoubleStream 组建了Java的流体系根基
• PipelineHelper主要用于Stream执行过程中相关结构的构建ReferencePipeline和AbstractPipeline
• AbstractPipeline是流水线的核心抽象类，用于构建和管理流水线。它的实现类就是流水线的节点。
• Head、StatelessOp、StatefulOp为ReferencePipeline中的内部类，[Int | Long | Double]Pipeline 内部也都是定义了这三个内部类。

IntPipeline, LongPipeline, DoublePipeline这三个类专门为三种基本类型而定制的，Int、long、double进行了优化，主要用于频繁的拆装箱。三者跟ReferencePipeline是并列关系，
StatefulOp、StatelessOp分别对应有状态和无状态中间操作。，很多Stream操作会需要一个回调函数（Lambda表达式），一个完整的操作是<数据来源，操作，回调函数>构成的三元组。

Stream中使用Stage的概念来描述一个完整的操作，将具有先后顺序的各个Stage连到一起，就构成了整个流水线。

AbstractPipeline

前面说到AbstractPipeline是流水线的核心。AbstractPipeline中定义了三个AbstractPipeline类型的变量：sourceStage（源阶段），previousStage（上游pipeline，前一阶段），nextStage（下一阶段）。

/**
 * Backlink to the head of the pipeline chain (self if this is the source stage).
 */
private final AbstractPipeline sourceStage;
/**
* The "upstream" pipeline, or null if this is the source stage.
*/
private final AbstractPipeline previousStage;
/**
 * The next stage in the pipeline, or null if this is the last stage.
 * Effectively final at the point of linking to the next pipeline.
 */
private AbstractPipeline nextStage;

它的直接实现类为ReferencePipeline，而Head 、StatefulOp 、StatelessOp又继承了ReferencePipeline类。因此Head StatefulOp StatelessOp 他们本身也是AbstractPipeline类型的。
每一个stage就是一个AbstractPipeline的实例，注意，刚开始笔者和Netty中的Pipelie做以类比，其实根本不是一回事。这里的每一个pipeline都是一个节点。

Head用于表示第一个Stage，也就是source stage，调用诸如Collection.stream()方法产生的Stage，很显然这个Stage里不包含任何操作；StatelessOp和StatefulOp分别表示无状态和有状态的Stage，对应于无状态和有状态的中间操作。
注意：终结操作不会添加节点。

Pipeline

Collection.stream()方法得到Head也就是stage0，紧接着调用一系列的中间操作，不断产生新的Stream。这些Stream对象以双向链表的形式组织在一起，构成整个流水线。
由于每个Stage都记录了前一个Stage和本次的操作以及回调函数，依靠这种结构就能建立起对数据源的所有操作。

下面分析Head节点的构建。

Stream的生成源码分析

不管是Collection中调用StreamSupport.stream()还是Stream的of方法 都是调用了StreamSupport.stream方法。以Collecton.stream()为例

default Stream<E> parallelStream() {
    return StreamSupport.stream(spliterator(), true);
}

这是一个接口方法的默认实现，第一个参数是获取一个 Spliterator的实例，它表示从数据源中获取元素的方式。相当于升级版的Iterator。第二个参数是是否并行。
继续进入StreamSupport类中：

public static <T> Stream<T> stream(Spliterator<T> spliterator, boolean parallel) {
    Objects.requireNonNull(spliterator);
    return new ReferencePipeline.Head<>(spliterator,
                                        StreamOpFlag.fromCharacteristics(spliterator),
                                        parallel);
}

看到这里和前面说的pipeline有点联系了，此处构造Head节点。我们看一下Head它的构造函数链：

Head(Spliterator<?> source,
  int sourceFlags, boolean parallel) {
  super(source, sourceFlags, parallel);//source - 描述流的源 sourceFlags - 流的来原标志 parallel - 是否为并行流
}
ReferencePipeline(Spliterator<?> source,
              int sourceFlags, boolean parallel) {
super(source, sourceFlags, parallel);
}
AbstractPipeline(Spliterator<?> source,
                 int sourceFlags, boolean parallel) {
    this.previousStage = null; // 上游管道，第一次创建流则为null
    this.sourceSpliterator = source; // 源分裂器。仅对头管道有效。
    this.sourceStage = this; // 反向链接到管道链的头部（如果这是源阶段，则为它本身）
    this.sourceOrOpFlags = sourceFlags & StreamOpFlag.STREAM_MASK; //此管道对象中表示的中间操作的操作标志。
    // The following is an optimization of:
    //源以及所有操作的组合源的操作标志，包括此管道对象表示的操作。在评估管道准备时有效。
    this.combinedFlags = (~(sourceOrOpFlags << 1)) & StreamOpFlag.INITIAL_OPS_VALUE;
    this.depth = 0; //此管道对象与流源（如果是顺序）之间的中间操作数，或之前的有状态（如果并行）。在评估管道准备时有效。
    this.parallel = parallel;//如果管道是并行的，则为真，否则管道是顺序的;仅对源阶段有效.
}

第一个构造函数对应的类为：static class Head<E_IN, E_OUT> extends ReferencePipeline<E_IN, E_OUT>，
注意这一有一个细节：范型的命名，<E_IN>上游源中的元素类型 <E_OUT>此阶段生成的元素类型
ReferencePipeline这个类由继承了AbstractPipeline<P_IN, P_OUT, Stream<P_OUT>>,同时实现了Stream<P_OUT>的各种操作符。
至此头结点已经构造完成。

添加中间操作

看看filter的代码：

@Override
public final Stream<P_OUT> filter(Predicate<? super P_OUT> predicate) {
    Objects.requireNonNull(predicate);
    return new StatelessOp<P_OUT, P_OUT>(this, StreamShape.REFERENCE,
                                 StreamOpFlag.NOT_SIZED) {
        @Override
        Sink<P_OUT> opWrapSink(int flags, Sink<P_OUT> sink) {
            return new Sink.ChainedReference<P_OUT, P_OUT>(sink) {
                @Override
                public void begin(long size) {
                    downstream.begin(-1);
                }

                @Override
                public void accept(P_OUT u) {
                    if (predicate.test(u))
                        downstream.accept(u);
                }
            };
        }
    };
}

可以看到返回了一个无状态stage，也是一个AbstractPipeline、stream，即是流水线的一个阶段。同时还实现了AbstractPipeline定义的opWrapSink方法。
看到这里似乎有些困惑，一片Override方法到底什么意思？

Sink
Stream中将操作抽象化为stage 每个stage 也就是一个AbstractPipeline，每个stage 相当于一个双向链表的节点 ,每个节点都保存Head然后保存着上一个和下一个节点。这个双向链表就构成了整个流水线。

但是似乎有一个最重要的东西没有提到，那么就是每一个阶段的操作。如何将多个操作叠加到一起呢？
你可能会觉得这很简单，只需要从流水线的head开始依次执行每一步的操作（包括回调函数）就行了。
这听起来似乎是可行的，但是你忽略了前面的Stage并不知道后面Stage到底执行了哪种操作，以及回调函数是哪种形式。换句话说，只有当前Stage本身才知道该如何执行自己包含的动作。这就需要有某种协议来协调相邻Stage之间的调用关系。这就是Sink接口存在的意义。
创建的Sink.ChainedReference类构造方法如下：

public ChainedReference(Sink<? super E_OUT> downstream) {
           this.downstream = Objects.requireNonNull(downstream);
       }

Sink接口相当于对操作(我们实现的函数式接口)封装了一层，每一个阶段只需要调用自己的Sink的accept方法，accept内部只要调用下一个阶段的accept
不需要知道下一个极端的操作类型是什么。

当然Sink添加进行一些扩展功能，比如：begin表示开始遍历元素前的方法，相当于AOP。end表示元素遍历结束之后，cancellationRequested表示是否可以结束操作，可以让短路操作尽早结束。

实际上Stream 操作符内部实现的的本质，就是实现Sink的这四个接口方法。
Sink接口的方法几乎都是按照这种[处理->转发]的模型实现，如上面的accept

1. 使用当前Sink包装的回调函数处理u
2. 将处理结果传递给流水线下游的Sink

当添加了中间操作符之后的链表结构如下,Head中没有任何操作，因此也没有实现Sink。

pipeline-sink

在这里产生一个疑问，重写的opWrapSink什么时候被调用？以及Sink的accept什么时候被调用？正如图中所示，我们只是重写了opWrapSink方法，保存在每一个节点中。每一个Sink都是独立的，它的downstream还没有赋值。

万事俱备，只欠东风

何为东风？显然是终结操作符，以forEach为例，实现在ReferencePipeline中：

@Override
public void forEach(Consumer<? super P_OUT> action) {
    evaluate(ForEachOps.makeRef(action, false));
}

ForEachOps是用户创建TerminalOp实例的工厂类。TerminalOp是终止操作最顶层的一个接口。TerminalOp接口的实现类有ForEachOp, ReduceOp,FindOp, MatchOp。
先看ForEachOps.makeRef（）方法：

public static <T> TerminalOp<T, Void> makeRef(Consumer<? super T> action,
                                              boolean ordered) {
    Objects.requireNonNull(action);
    return new ForEachOp.OfRef<>(action, ordered);
}

OfRef是引用流的默认实现类，这里新建了一个OfRef的实例，构造方法如下：

OfRef(Consumer<? super T> consumer, boolean ordered) {
    super(ordered);// 父类ForEachOp，参数表述遍历是否有序，前面传入的false
    this.consumer = consumer;
}

将我们实现的Consumer函数式接口赋值给成员变量。回到evaluate方法:

final <R> R evaluate(TerminalOp<E_OUT, R> terminalOp) {
    assert getOutputShape() == terminalOp.inputShape();
    if (linkedOrConsumed)
        throw new IllegalStateException(MSG_STREAM_LINKED);
    linkedOrConsumed = true;

    return isParallel()
           ? terminalOp.evaluateParallel(this, sourceSpliterator(terminalOp.getOpFlags()))
           : terminalOp.evaluateSequential(this, sourceSpliterator(terminalOp.getOpFlags()));
}

跟到串行流的实现,实现在ForEachOp中：

@Override
public <S> Void evaluateSequential(PipelineHelper<T> helper,
                                   Spliterator<S> spliterator) {
    return helper.wrapAndCopyInto(this, spliterator).get();
}

数PipelineHelper类型其实是AbstractPipeline的父类，而AbstractPipeline又是ReferencePipeline的父类。再跟进helper.wrapAndCopyInto方法，是现在AbstractPipeline中：

@Override
final <P_IN, S extends Sink<E_OUT>> S wrapAndCopyInto(S sink, Spliterator<P_IN> spliterator) {
    copyInto(wrapSink(Objects.requireNonNull(sink)), spliterator);
    return sink;
}
final <P_IN> Sink<P_IN> wrapSink(Sink<E_OUT> sink) {
    for ( @SuppressWarnings("rawtypes") AbstractPipeline p=AbstractPipeline.this; p.depth > 0; p=p.previousStage) {
        sink = p.opWrapSink(p.previousStage.combinedFlags, sink);
    }
    return (Sink<P_IN>) sink;
}

可以看到通过ReferencePipeline的双向链表，从最后一个操作（也就是终止操作）往前遍历，将所有的操作都串联起来，最终返回一个指向第一个操作的Sink引用。

这里有一个细节问题：
final <P_IN, S extends Sink<E_OUT>> S wrapAndCopyInto(S sink, Spliterator<P_IN> spliterator)方法的第一个入参为泛型，几Sink的子类。对应的有Sink.ofLong、Sink.ofInt等。并且这个参数也属于TerminalOp类型，说白了终结操作符最终也被包装成了Sink类型，这一切都通了，最后一个中间操作的downStream是终结操作符。

真的要执行了
回到copyInto方法，wrapSink返回了Head后第一个中间操作的包装Sink，继续看copyInto的实现：

@Override
final <P_IN> void copyInto(Sink<P_IN> wrappedSink, Spliterator<P_IN> spliterator) {
    Objects.requireNonNull(wrappedSink);

    if (!StreamOpFlag.SHORT_CIRCUIT.isKnown(getStreamAndOpFlags())) {
        wrappedSink.begin(spliterator.getExactSizeIfKnown());
        spliterator.forEachRemaining(wrappedSink);
        wrappedSink.end();
    }
    else {
        copyIntoWithCancel(wrappedSink, spliterator);
    }
}

第一个参数我们知道Head后的节点，spliterator可以看作数据源。逻辑分为短路操作和非短路操作，如果有短路操作就会执行下面的copyIntoWithCancel方法，否则指向上面的逻辑，这里我们非常熟悉啊，begin、accept、end先后串联执行。

短路流在执行遍历的时候会调用Sink封装的cancellationRequested方法，如果返回出就不会进行后面的操作，过程稍微比非短路复杂一点，但是原理大致相同。