java8 stream运行原理之并行流原理详解

上一篇文章《java8 stream运行原理之顺序流原理详解》介绍了顺序流的执行原理,本文接着上一篇介绍并行流的执行原理。

一、如何创建并行流

调用parallel()方法可以创建并行流,如下:

    public static void main(String argv[]){
        Stream<String> stream=Stream.of("1","2","","123");
        stream.filter(x->x.length()>=1).parallel().forEach(System.out::println);
    }

二、并行流原理

下面以第一小节的代码为例,介绍一下并行流原理。
这里只介绍最后的终端操作(forEach),对于如何创建Stream流,以及中间操作原理请参见上一篇文章。

1、parallel()

首先来看一下parallel()方法:

    public final S parallel() {
    	//sourceStage是Head对象引用
    	//将Head对象的parallel属性设置为true
        sourceStage.parallel = true;
        return (S) this;
    }

parallel()方法仅仅将Head对象的parallel属性设置为true。

2、forEach()

下面是forEach()方法源码:

    public void forEach(Consumer<? super P_OUT> action) {
    	//makeRef()创建TerminalOp对象
        evaluate(ForEachOps.makeRef(action, false));
    }
    final <R> R evaluate(TerminalOp<E_OUT, R> terminalOp) {
        assert getOutputShape() == terminalOp.inputShape();
        if (linkedOrConsumed)
            throw new IllegalStateException(MSG_STREAM_LINKED);
        linkedOrConsumed = true;
		//检查sourceStage.parallel的值,如果为true,表示是并行流
        return isParallel()
               ? terminalOp.evaluateParallel(this, sourceSpliterator(terminalOp.getOpFlags()))
               : terminalOp.evaluateSequential(this, sourceSpliterator(terminalOp.getOpFlags()));
    }

在forEach()里面调用了terminalOp.evaluateParallel()进行并行处理。下面是terminalOp.evaluateParallel()的方法:

    public <S> Void evaluateParallel(PipelineHelper<T> helper,
                                     Spliterator<S> spliterator) {
        //ordered表示是否有序遍历,true表示有序
        //forEach操作默认ordered都是false
        if (ordered)
            new ForEachOrderedTask<>(helper, spliterator, this).invoke();
        else
            new ForEachTask<>(helper, spliterator, helper.wrapSink(this)).invoke();
        return null;
    }

在evaluateParallel()方法里面创建ForEachTask对象。
ForEachTask实现了ForkJoinTask类,而这个ForkJoinTask是Fork/Join框架中的,这是java7新增的功能。Fork/Join框架对并行处理做了很多优化。
上面代码的最后调用了invoker()方法,这个方法会调用到ForEachTask.compute()方法:

public void compute() {
	  //将数据源拆分为两部分,分别交给两个不同的线程处理,
	  //这两部分使用rightSplit和leftSplit记录
      Spliterator<S> rightSplit = spliterator, leftSplit;
      long sizeEstimate = rightSplit.estimateSize(), sizeThreshold;
      if ((sizeThreshold = targetSize) == 0L)
          targetSize = sizeThreshold = AbstractTask.suggestTargetSize(sizeEstimate);
      boolean isShortCircuit = StreamOpFlag.SHORT_CIRCUIT.isKnown(helper.getStreamAndOpFlags());
      boolean forkRight = false;
      Sink<S> taskSink = sink;
      ForEachTask<S, T> task = this;
      while (!isShortCircuit || !taskSink.cancellationRequested()) {
          //rightSplit.trySplit()可以对数据源的数据进行拆分,将数据一分为二
          //如果剩余的数据量不足以进行再次拆分,则直接使用当前线程处理
          if (sizeEstimate <= sizeThreshold ||
              (leftSplit = rightSplit.trySplit()) == null) {
              task.helper.copyInto(taskSink, rightSplit);
              break;
          }
          //将数据拆分为两部分后,左半部分的数据再创建ForEachTask对象
          ForEachTask<S, T> leftTask = new ForEachTask<>(task, leftSplit);
          task.addToPendingCount(1);
          ForEachTask<S, T> taskToFork;
          //forkRight相当于一个开关,如果上次启动任务处理左半部分数据,那么这次启动任务处理右半部分数据
          if (forkRight) {
              forkRight = false;
              rightSplit = leftSplit;
              taskToFork = task;
              task = leftTask;
          }
          else {
              forkRight = true;
              taskToFork = leftTask;
          }
          //调用fork()可以将任务加入到待处理队列中,后续线程池中的线程会将任务取走处理
          taskToFork.fork();
          sizeEstimate = rightSplit.estimateSize();
      }
      task.spliterator = null;
      task.propagateCompletion();
  }
}		

并行流处理的核心逻辑就在compute()方法里面,下面总结一下并行流的执行流程:

  1. 调用Spliterator.trySplit()拆分流,将流一拆为二,如果不能再拆分,那么调用Sink对象链表处理数据;
  2. 拆分为两部分数据后,右半部分的数据使用当前ForEachTask对象处理,左半部分数据新创建一个ForEachTask对象处理,之后分别启动线程处理这两个任务。

如果处理流的操作都是无状态的,那么执行会像上面介绍的一样在终端操作里面创建并行任务,如果中间操作有有状态的,那么在创建Spliterator对象时,会先将该有状态操作以及之前的所有操作并行执行一次,得到的结果作为Spliterator对象,然后将该Spliterator对象传递给终端操作,这一段处理逻辑可以参见方法sourceSpliterator():

    private Spliterator<?> sourceSpliterator(int terminalFlags) {
        // Get the source spliterator of the pipeline
        Spliterator<?> spliterator = null;
        if (sourceStage.sourceSpliterator != null) {
            spliterator = sourceStage.sourceSpliterator;
            sourceStage.sourceSpliterator = null;
        }
        else if (sourceStage.sourceSupplier != null) {
            spliterator = (Spliterator<?>) sourceStage.sourceSupplier.get();
            sourceStage.sourceSupplier = null;
        }
        else {
            throw new IllegalStateException(MSG_CONSUMED);
        }
		//如果是并行流且有有状态的操作,那么下面的if分支判断为true
        if (isParallel() && sourceStage.sourceAnyStateful) {
            // Adapt the source spliterator, evaluating each stateful op
            // in the pipeline up to and including this pipeline stage.
            // The depth and flags of each pipeline stage are adjusted accordingly.
            int depth = 1;
            //从Head开始遍历各个操作对象
            for (@SuppressWarnings("rawtypes") AbstractPipeline u = sourceStage, p = sourceStage.nextStage, e = this;
                 u != e;
                 u = p, p = p.nextStage) {

                int thisOpFlags = p.sourceOrOpFlags;
                //如果当前操作是有状态的
                if (p.opIsStateful()) {
                    depth = 0;//操作对象链表深度记为0
                    if (StreamOpFlag.SHORT_CIRCUIT.isKnown(thisOpFlags)) {
                        // Clear the short circuit flag for next pipeline stage
                        // This stage encapsulates short-circuiting, the next
                        // stage may not have any short-circuit operations, and
                        // if so spliterator.forEachRemaining should be used
                        // for traversal
                        thisOpFlags = thisOpFlags & ~StreamOpFlag.IS_SHORT_CIRCUIT;
                    }
					//将数据进行并行处理,只执行当前有状态的操作以及它前面的操作
					//将操作的结果创建一个Spliterator对象,
					//该Spliterator对象接下来就作为后面流处理的数据源
                    spliterator = p.opEvaluateParallelLazy(u, spliterator);

                    // Inject or clear SIZED on the source pipeline stage
                    // based on the stage's spliterator
                    thisOpFlags = spliterator.hasCharacteristics(Spliterator.SIZED)
                            ? (thisOpFlags & ~StreamOpFlag.NOT_SIZED) | StreamOpFlag.IS_SIZED
                            : (thisOpFlags & ~StreamOpFlag.IS_SIZED) | StreamOpFlag.NOT_SIZED;
                }
                //操作对象链表深度加1 ,如果中间操作有有状态的,那么该有状态的操作深度为0,
                //相当于接下来以该有状态操作对象作为链表起点
                p.depth = depth++;
                p.combinedFlags = StreamOpFlag.combineOpFlags(thisOpFlags, u.combinedFlags);
            }
        }
        if (terminalFlags != 0)  {
            // Apply flags from the terminal operation to last pipeline stage
            combinedFlags = StreamOpFlag.combineOpFlags(terminalFlags, combinedFlags);
        }
        return spliterator;
    }

你可能感兴趣的:(java8,java,Stream,并行流)