Question

我刚开始学习Java 8中的Stream API和一般的函数式编程，但不是Java新手。我有兴趣了解并了解Stream API如何选择执行计划。

如何知道要并行化的哪些部分以及哪些部分不能？甚至存在多少种执行计划？

基本上，我想知道为什么Java 8中的Streams有助于提高速度，以及它如何做到这一点＆＃34;魔术＆＃34;。

我无法找到关于它如何运作的大量文献。

Answer 1

这个问题有点详细解释，但我会尽力满足。我还使用了ArrayList的一个例子。

当我们创建流时，返回的对象称为ReferencePipeline。这个对象是“默认流”对象，因为它还没有任何功能。现在我们必须在懒惰和渴望的方法之间做出决定。那么让我们看看每个例子。

示例一：filter(Predicate<?>)方法：

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);
                }
            };
        }
    };
}

正如您所看到的，它会返回一个StatelessOp对象，该对象基本上是一个新的ReferencePipeline，其中过滤器评估现在是'enabled'。换句话说：每当我们向流添加新的“功能”时，它就会根据旧的管道创建一个新的管道，并使用正确的操作标志/方法覆盖。
您可能已经知道，在调用急切操作之前，不会对流进行评估。所以我们需要一种急切的方法来评估流。

例二：forEach(Consumer<?>)方法：

@Override
public void forEach(Consumer<? super P_OUT> action) {
    evaluate(ForEachOps.makeRef(action, false));
}

首先这是相当短的，而evaluate()方法只会调用invoke()方法。在此，了解ForEachOps.makeRef()的作用非常重要。它设置了创建ForEachTask<>所需的最后一个标志，它与ForkJoinTask对象完全相同。很高兴Andrew找到了一个关于它们如何工作的好paper。

注意：可以找到确切的源代码here。

Answer 2

您可能已经知道，Stream API使用Spliterator和ForkJoinPool来执行并行计算。 Spliterator用于遍历和分区元素序列，而ForkJoinPool框架递归地将任务分解为较小的独立子任务，直到它们足够简单以便异步执行。

作为并行计算框架（例如java.util.stream包）如何在并行计算中使用Spliterator和ForkJoinPool的示例，以下是实现关联并行的一种方法forEach，它说明了主要习语：

public static void main(String[] args) {
    List<Integer> list = new SplittableRandom()
        .ints(24, 0, 100)
        .boxed().collect(Collectors.toList());

    parallelEach(list, System.out::println);
}

static <T> void parallelEach(Collection<T> c, Consumer<T> action) {
    Spliterator<T> s = c.spliterator();
    long batchSize = s.estimateSize() / (ForkJoinPool.getCommonPoolParallelism() * 8);
    new ParallelEach(null, s, action, batchSize).invoke(); // invoke the task
}

Fork加入任务：

static class ParallelEach<T> extends CountedCompleter<Void> {
    final Spliterator<T> spliterator;
    final Consumer<T> action;
    final long batchSize;

    ParallelEach(ParallelEach<T> parent, Spliterator<T> spliterator,
                 Consumer<T> action, long batchSize) {
        super(parent);
        this.spliterator = spliterator;
        this.action = action;
        this.batchSize = batchSize;
    }

    // The main computation performed by this task
    @Override
    public void compute() {
        Spliterator<T> sub;
        while (spliterator.estimateSize() > batchSize &&
              (sub = spliterator.trySplit()) != null) {
            addToPendingCount(1);
            new ParallelEach<>(this, sub, action, batchSize).fork();
        }
        spliterator.forEachRemaining(action);
        propagateCompletion();
    }
}

Original source.

另外，请记住，并行计算可能并不总是比顺序计算更快，而且您总是可以选择 - When to use parallel stream。

Java Stream API如何选择执行计划？

2 个答案: