浅析Java8 Stream原理

文章目录

  • 操作符的分类
  • 流水线的结构
  • 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方法,如果返回出就不会进行后面的操作,过程稍微比非短路复杂一点,但是原理大致相同。

推荐阅读更多精彩内容

  • Int Double Long 设置特定的stream类型, 提高性能,增加特定的函数 无存储。stream不是一...
    patrick002阅读 636评论 0 0
  • Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具(例如配置管理,服务发现,断路器,智...
    卡卡罗2017阅读 83,980评论 14 122
  • /Library/Java/JavaVirtualMachines/jdk-9.jdk/Contents/Home...
    一个会写诗的程序员阅读 2,186评论 2 6
  • Java8 Stream原理深度解析 Author:DoraeDate:2017年11月2日19:10:39转载请...
    Dorae132阅读 1,965评论 0 12
  • λ表达式 什么是λ表达式 λ表达式有三部分组成:参数列表,箭头(->),以及一个表达式或者语句块。 转换为λ表达式...
    輕狂丨書生阅读 1,167评论 1 11