一、简介
Java8支持的流处理的元素类型有4种，double、int，long和reference类型。
AbstractPipeline有4个子类，分别表示流处理元素为double、int，long和reference类型的管道。这4个子类都是抽象类，每个子类下都有3个静态内部类的实现类，Head、StatefulOp、StatelessOp，其中Head用于创建一个全新的流，StatefulOp表示有状态的一类操作，StatelessOp表示无状态的一类操作，这里的有状态是指前面流元素的处理会直接影响后面流元素的处理，多线程并行处理下每次运行的结果都不相同。这4个AbstractPipeline子类的用法和实现是基本一致的，下面是ReferenceStream的继承树：
二、AbstractPipeline
list.stream()
// 上述代码实际调用的是
public final class StreamSupport {
public static <T> Stream<T> stream(Spliterator<T> spliterator, boolean parallel) {
Objects.requireNonNull(spliterator);
return new ReferencePipeline.Head<>(spliterator,
StreamOpFlag.fromCharacteristics(spliterator),
parallel);
}
}
// 一步步点进去，new的是这个
abstract class AbstractPipeline<E_IN, E_OUT, S extends BaseStream<E_OUT, S>>
extends PipelineHelper<E_OUT> implements BaseStream<E_OUT, S> {
// 初始的包含待处理的流
private final AbstractPipeline sourceStage;
// 上一个流处理动作
@SuppressWarnings("rawtypes")
private final AbstractPipeline previousStage;
// 当前流处理动作的标识
protected final int sourceOrOpFlags;
// 非终止类型的操作标识个数
private int depth;
// 全部操作标识
private int combinedFlags;
// 当前流处理对应的Spliterator
private Spliterator<?> sourceSpliterator;
//是否并行流处理
private boolean parallel;
...
AbstractPipeline(Spliterator<?> source,
int sourceFlags, boolean parallel) {
this.previousStage = null;
this.sourceSpliterator = source;
this.sourceStage = this;
this.sourceOrOpFlags = sourceFlags & StreamOpFlag.STREAM_MASK;
// The following is an optimization of:
// StreamOpFlag.combineOpFlags(sourceOrOpFlags, StreamOpFlag.INITIAL_OPS_VALUE);
this.combinedFlags = (~(sourceOrOpFlags << 1)) & StreamOpFlag.INITIAL_OPS_VALUE;
this.depth = 0;
this.parallel = parallel;
}
...
}
// 看filter实现
list.stream().filter()
// 有三个静态内部类
abstract class ReferencePipeline<P_IN, P_OUT>
extends AbstractPipeline<P_IN, P_OUT, Stream<P_OUT>>
implements Stream<P_OUT> {
...
public final Stream<P_OUT> filter(Predicate<? super P_OUT> predicate) {
Objects.requireNonNull(predicate);
// 返回一个新的ReferencePipeline实例（最后调用的也是下面的AbstractPipeline构造器）
return new StatelessOp<P_OUT, P_OUT>(this, StreamShape.REFERENCE,
StreamOpFlag.NOT_SIZED) {
// Sink部分解释
@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);
}
};
}
};
}
...
}
abstract class AbstractPipeline<E_IN, E_OUT, S extends BaseStream<E_OUT, S>>
extends PipelineHelper<E_OUT> implements BaseStream<E_OUT, S> {
// 流是否已经开始
private boolean linkedOrConsumed;
...
AbstractPipeline(AbstractPipeline<?, E_IN, ?> previousStage, int opFlags) {
if (previousStage.linkedOrConsumed)
throw new IllegalStateException(MSG_STREAM_LINKED);
previousStage.linkedOrConsumed = true;
previousStage.nextStage = this;
this.previousStage = previousStage;
this.sourceOrOpFlags = opFlags & StreamOpFlag.OP_MASK;
this.combinedFlags = StreamOpFlag.combineOpFlags(opFlags, previousStage.combinedFlags);
this.sourceStage = previousStage.sourceStage;
if (opIsStateful())
sourceStage.sourceAnyStateful = true;
this.depth = previousStage.depth + 1;
}
}
Stream 中创建流和中间操作都会形成一个 AbstractPipeline，组成一个双向链表，每添加一个中间操作，就会在链表结尾新增一个 AbstractPipeline 节点。
三、Sink
每个中间操作都会实现 opWrapSink() 方法，创建 ChainedReference 类。图中可以看到 Sink 继承了 Consumer 接口多了 begin() 和 end() 方法，采用静态代理及装饰器模式，有四个内部静态抽象实现类。
每一个中间操作都会new Sink.ChainedReference() 并重写 accept() 方法（执行并调用下游 sink 的 accept 方法），终结操作时调用，构成 sink 链表。
四、终结操作
// collect方法点进去
list.stream().filter().collect(Collectors.toList())
@Override
abstract class ReferencePipeline<P_IN, P_OUT>
extends AbstractPipeline<P_IN, P_OUT, Stream<P_OUT>>
implements Stream<P_OUT> {
...
@SuppressWarnings("unchecked")
public final <R, A> R collect(Collector<? super P_OUT, A, R> collector) {
A container;
// 是否并行，先看不并行的
if (isParallel()
&& (collector.characteristics().contains(Collector.Characteristics.CONCURRENT))
&& (!isOrdered() || collector.characteristics().contains(Collector.Characteristics.UNORDERED))) {
container = collector.supplier().get();
BiConsumer<A, ? super P_OUT> accumulator = collector.accumulator();
forEach(u -> accumulator.accept(container, u));
}
else {
// 点进去
container = evaluate(ReduceOps.makeRef(collector));
}
return collector.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)
? (R) container
: collector.finisher().apply(container);
}
...
}
// 1、ReduceOps.makeRef(collector)
// final类
final class ReduceOps {
...
public static <T, I> TerminalOp<T, I>
makeRef(Collector<? super T, I, ?> collector) {
// 被下面的局部内部类使用，JDK1.8编译时自动添加final关键字，放在常量池中，供堆中局部内部类调用
Supplier<I> supplier = Objects.requireNonNull(collector).supplier();
BiConsumer<I, ? super T> accumulator = collector.accumulator();
BinaryOperator<I> combiner = collector.combiner();
// 局部内部类，保存上面的三个属性，并实现Sink里的方法，下面是继承树
class ReducingSink extends Box<I>
implements AccumulatingSink<T, I, ReducingSink> {
@Override
public void begin(long size) {
state = supplier.get();
}
@Override
public void accept(T t) {
accumulator.accept(state, t);
}
@Override
public void combine(ReducingSink other) {
state = combiner.apply(state, other.state);
}
}
// ReduceOp是一个私有静态抽象内部类，这里实现了makeSink方法，返回ReducingSink（栈退出后，仍在堆中能找到）
return new ReduceOp<T, I, ReducingSink>(StreamShape.REFERENCE) {
@Override
public ReducingSink makeSink() {
return new ReducingSink();
}
@Override
public int getOpFlags() {
return collector.characteristics().contains(Collector.Characteristics.UNORDERED)
? StreamOpFlag.NOT_ORDERED
: 0;
}
};
}
...
}
// 2、evaluate(ReduceOps.makeRef(collector))
class AbstractPipeline {
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()));
}
}
class ReduceOps {
@Override
public <P_IN> R evaluateSequential(PipelineHelper<T> helper,
Spliterator<P_IN> spliterator) {
// helper是最后一个操作的（也是当前所处的）AbstractPipeline
// makeSink()返回的是1中那个局部内部类
return helper.wrapAndCopyInto(makeSink(), spliterator).get();
}
}
class 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;
}
// 通过最后一个AbstractPipeline的previousStage向前遍历，构建Sink链表，返回链表头（第一个中间操作）
@Override
@SuppressWarnings("unchecked")
final <P_IN> Sink<P_IN> wrapSink(Sink<E_OUT> sink) {
Objects.requireNonNull(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;
}
// 从第一个中间操作到最后一个中间操作顺序执行begin，再依次执行accept，最后依次执行end
@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);
}
}
}
五、心得
了解了Stream流操作的底层框架、原理。
静态代理函数式接口；各种内部类，有装饰器模式的、final不可继承的类、private必须使用外部类操作的私有类、通过方法返回的局部内部类。
扫一扫
598
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
