Stream源码笔记（一）

一、简介

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必须使用外部类操作的私有类、通过方法返回的局部内部类。