为什么JavaStream.forEach方法在某些情况下比其他循环更快？

Question

我目前正在承担一个项目，我正在使用Java微基准线束（JMH）框架测量Java中不同类型循环的速度。我得到了一些关于流的有趣结果，我无法解释，并且想知道是否更了解流和数组列表的人可以帮助我解释我的结果。

基本上，当遍历大小为100的数组列表时，stream.forEach方法比任何其他类型的循环都快得多：

我的结果图表显示在这里:https://i.imgur.com/ypXoWWq.png

我尝试过使用对象和字符串的数组列表，并且都产生类似的结果。随着列表的大小越来越大，流方法仍然更快，但其他列表之间的性能差距会变小。我不知道是什么导致了这些结果。

@Fork(5)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 10, time = 100, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 100, timeUnit = TimeUnit.MILLISECONDS)
@State(Scope.Thread)
public class StackOverflowQ {

    List<Integer> intList;

    int size = 100;

    @Setup
    public void setup() {
        intList = new ArrayList<>(size);
        for(int i = 0; i<size;i++){
            intList.add(i);
        }
    }

    /**
     Work done to each item in the loop.
     */
    public double doWork(int item) {
        return item + 47;
    }

    @Benchmark
    public void standardFor(Blackhole bh){
        for (int i = 0; i<intList.size(); i++){
            bh.consume(doWork(intList.get(i)));
        }
    }

    @Benchmark
    public void streamForEach(Blackhole bh){
        intList.stream().forEach(i -> bh.consume(doWork(i)));
    }

}

Answer 1

这个答案讨论了java.util.ArrayList。其他Collection实现可能（并且确实！）显示完全不同的结果。

简而言之：因为流使用Spliterator而不是Iterator

基于< code>Iterator的迭代基于< code>hasNext和< code>next方法调用，其中第二个调用会使< code>Iterator实例发生变异。这带来了一些性能成本。< code > split operator 支持批量迭代。点击此处了解更多信息。增强的for循环(< code>for (T e : iterable) {...})似乎使用了< code >迭代器。

性能通常应该是次要问题；您应该使用最能描述您意图的结构。虽然由于向后兼容的原因，这将是困难的，但也许基于spliterator的forEach和增强的for循环(在< code>ArrayList上)之间的性能差异在将来会消失。

循环索引怎么样？（List#get（int））
它们显示出比分裂器更差的性能，部分原因是它们需要验证索引。其他原因可能包括方法调用，例如。在索引处获取数据，而Spliterator直接访问数组。但这纯粹是猜测。

下面您可以看到一个微小的基准，它证实了所述的理论。请注意，最佳情况下，基准应该运行更长时间。

@State(Scope.Benchmark)
@Fork(value = 2)
@Warmup(iterations = 2, time = 3)
@Measurement(iterations = 2, time = 3)
public class A {
    
    public List<Object> list;
    
    @Setup
    public void setup() {
        list = new ArrayList<>();
        for (int i = 0; i < 1000; i++) list.add(i);
    }
    
    @Benchmark
    public void collectionForEach(Blackhole hole) {
        list.forEach(hole::consume);
    }
    
    @Benchmark
    public void iteratorFor(Blackhole hole) {
        for (Iterator<Object> iterator = list.iterator(); iterator.hasNext(); ) {
            hole.consume(iterator.next());
        }
    }
    
    @Benchmark
    public void enhancedFor(Blackhole hole) {
        for (Object e : list) {
            hole.consume(e);
        }
    }
    
    @Benchmark
    public void iteratorForEach(Blackhole hole) {
        list.iterator().forEachRemaining(hole::consume);
    }
    
    @Benchmark
    public void indexedFor(Blackhole hole) {
        for (int i = 0, size = list.size(); i < size; i++) {
            hole.consume(list.get(i));
        }
    }
    
    @Benchmark
    public void streamForEach(Blackhole hole) {
        list.stream().forEach(hole::consume);
    }
    
    @Benchmark
    public void spliteratorForEach(Blackhole hole) {
        list.spliterator().forEachRemaining(hole::consume);
    }
}

结果。“操作/秒”表示操作/秒，越高越好。

Benchmark              Mode  Cnt       Score      Error  Units
A.collectionForEach   thrpt    4  158047.064 ±  959.534  ops/s
A.iteratorFor         thrpt    4  177338.462 ± 3245.129  ops/s
A.enhancedFor         thrpt    4  177508.037 ± 1629.494  ops/s
A.iteratorForEach     thrpt    4  184919.605 ± 1922.114  ops/s
A.indexedFor          thrpt    4  193318.529 ± 2715.611  ops/s
A.streamForEach       thrpt    4  280963.272 ± 2253.621  ops/s
A.spliteratorForEach  thrpt    4  283264.539 ± 3055.967  ops/s