文章目录
操作符的分类
流水线的结构
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 parallelStream() {
return StreamSupport.stream(spliterator(), true);
}
这是一个接口方法的默认实现，第一个参数是获取一个 Spliterator的实例，它表示从数据源中获取元素的方式。相当于升级版的Iterator。第二个参数是是否并行。
继续进入StreamSupport类中：
public static Stream stream(Spliterator 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 extends ReferencePipeline，
注意这一有一个细节：范型的命名，上游源中的元素类型 此阶段生成的元素类型
ReferencePipeline这个类由继承了AbstractPipeline>,同时实现了Stream的各种操作符。
至此头结点已经构造完成。
添加中间操作
看看filter的代码：
@Override
public final Stream filter(Predicate super P_OUT> predicate) {
Objects.requireNonNull(predicate);
return new StatelessOp(this, StreamShape.REFERENCE,
StreamOpFlag.NOT_SIZED) {
@Override
Sink opWrapSink(int flags, Sink sink) {
return new Sink.ChainedReference(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 TerminalOp 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 evaluate(TerminalOp 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 Void evaluateSequential(PipelineHelper helper,
Spliterator spliterator) {
return helper.wrapAndCopyInto(this, spliterator).get();
}
数PipelineHelper类型其实是AbstractPipeline的父类，而AbstractPipeline又是ReferencePipeline的父类。再跟进helper.wrapAndCopyInto方法，是现在AbstractPipeline中：
@Override
final > S wrapAndCopyInto(S sink, Spliterator spliterator) {
copyInto(wrapSink(Objects.requireNonNull(sink)), spliterator);
return sink;
}
final Sink wrapSink(Sink sink) {
for ( @SuppressWarnings("rawtypes") AbstractPipeline p=AbstractPipeline.this; p.depth > 0; p=p.previousStage) {
sink = p.opWrapSink(p.previousStage.combinedFlags, sink);
}
return (Sink) sink;
}
可以看到通过ReferencePipeline的双向链表，从最后一个操作(也就是终止操作)往前遍历，将所有的操作都串联起来，最终返回一个指向第一个操作的Sink引用。
这里有一个细节问题：
final > S wrapAndCopyInto(S sink, Spliterator spliterator)方法的第一个入参为泛型，几Sink的子类。对应的有Sink.ofLong、Sink.ofInt等。并且这个参数也属于TerminalOp类型，说白了终结操作符最终也被包装成了Sink类型，这一切都通了，最后一个中间操作的downStream是终结操作符。
真的要执行了
回到copyInto方法，wrapSink返回了Head后第一个中间操作的包装Sink，继续看copyInto的实现：
@Override
final void copyInto(Sink wrappedSink, Spliterator 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方法，如果返回出就不会进行后面的操作，过程稍微比非短路复杂一点，但是原理大致相同。
扫一扫
2055
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
