我最近在分析代码,发现其中一个有趣的瓶颈。这是基准:

@BenchmarkMode(Mode.Throughput)
@Fork(1)
@State(Scope.Thread)
@Warmup(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS)
public class Contains {

    private int[] ar = new int[] {1,2,3,4,5,6,7};

    private int val = 5;

    @Benchmark
    public boolean naive() {
        return contains(ar, val);
    }

    @Benchmark
    public boolean lambdaArrayStreamContains() {
        return Arrays.stream(ar).anyMatch(i -> i == val);
    }

    @Benchmark
    public boolean lambdaIntStreamContains() {
        return IntStream.of(ar).anyMatch(i -> i == val);
    }

    private static boolean contains(int[] ar, int value) {
        for (int arVal : ar) {
            if (arVal == value) {
                return true;
            }
        }
        return false;
    }

}

结果:
Benchmark                            Mode  Cnt       Score      Error  Units
Contains.lambdaArrayStreamContains  thrpt   10   22867.962 ± 1049.649  ops/s
Contains.lambdaIntStreamContains    thrpt   10   22983.800 ±  593.580  ops/s
Contains.naive                      thrpt   10  228002.406 ± 8591.186  ops/s

如果显示Array包含通过lambda进行的操作比使用简单循环的朴素实现慢10倍。我知道lambda应该会慢一些。但是十倍?我做错了lambda还是这是java的问题?

最佳答案

您的基准测试实际上并不衡量anyMatch性能,而是衡量流开销。与非常简单的操作(如五元素数组查找)相比,此开销可能会很明显。

如果我们从相对数转为绝对数,增速放缓看起来不会那么可怕。让我们测量延迟而不是吞吐量,以获得更清晰的画面。我已经省略了lambdaIntStream基准测试,因为它的工作方式与lambdaArrayStream完全相同。

Benchmark                   Mode  Cnt   Score   Error  Units
Contains.lambdaArrayStream  avgt    5  53,242 ± 2,034  ns/op
Contains.naive              avgt    5   5,876 ± 0,404  ns/op

5.8 ns大约是2.4 GHz CPU的14个周期。工作量如此之小,以至于任何额外的周期都会很明显。那么流操作的开销是多少?

对象分配

现在,使用-prof gc分析器重新运行基准测试。它将显示堆分配的数量:
Benchmark                                       Mode  Cnt     Score     Error   Units
Contains.lambdaArrayStream:·gc.alloc.rate.norm  avgt    5   152,000 ±   0,001    B/op
Contains.naive:·gc.alloc.rate.norm              avgt    5    ≈ 10⁻⁵              B/op
lambdaArrayStream每次迭代分配152个字节,而naive基准测试则不分配任何内容。当然,分配不是免费的:至少构造了5个对象来支持anyMatch,每个对象都需要几纳秒的时间:
  • Lambda i -> i == val
  • IntPipeline.Head
  • Spliterators.IntArraySpliterator
  • MatchOps.MatchOp
  • MatchOps.MatchSink

  • 调用堆栈
    java.util.stream实现有点复杂,因为它必须支持流源,中间操作和终端操作的所有组合。如果您在基准测试中查看anyMatch的调用堆栈,则会看到类似以下内容:
        at bench.Contains.lambda$lambdaArrayStream$0(Contains.java:24)
        at java.util.stream.MatchOps$2MatchSink.accept(MatchOps.java:119)
        at java.util.Spliterators$IntArraySpliterator.tryAdvance(Spliterators.java:1041)
        at java.util.stream.IntPipeline.forEachWithCancel(IntPipeline.java:162)
        at java.util.stream.AbstractPipeline.copyIntoWithCancel(AbstractPipeline.java:498)
        at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:485)
        at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:471)
        at java.util.stream.MatchOps$MatchOp.evaluateSequential(MatchOps.java:230)
        at java.util.stream.MatchOps$MatchOp.evaluateSequential(MatchOps.java:196)
        at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
        at java.util.stream.IntPipeline.anyMatch(IntPipeline.java:477)
        at bench.Contains.lambdaArrayStream(Contains.java:23)
    

    并非所有这些方法调用都可以内联。此外,JVM将内联限制为9个级别,但是在这里我们看到了更深的调用堆栈。如果我们使用-XX:MaxInlineLevel=20覆盖该限制,则得分会更好一些:
    Benchmark                   Mode  Cnt   Score   Error  Units
    Contains.lambdaArrayStream  avgt    5  33,294 ± 0,367  ns/op  (was 53,242)
    Contains.naive              avgt    5   5,822 ± 0,207  ns/op
    

    循环优化

    数组上的for迭代是一个简单的计数循环。 JVM可以在此处应用各种循环优化:循环剥离,循环展开等。这不适用于while方法中的forEachWithCancel -kind循环,该循环用于遍历IntStream。循环优化的效果可以使用-XX:LoopUnrollLimit=0 -XX:-UseLoopPredicate来衡量:
    Benchmark                   Mode  Cnt   Score   Error  Units
    Contains.lambdaArrayStream  avgt    5  33,153 ± 0,559  ns/op
    Contains.naive              avgt    5   9,853 ± 0,150  ns/op  (was 5,876)
    

    结论

    的构造和遍历流的一些开销,但这是完全可以理解的,不能视为错误。我不会说开销很大(即使50 ns / op也不算多);但是,在此特定示例中,由于工作量极小,因此开销占主导。

    关于java - 为什么lambda IntStream.anyMatch()比朴素的实现慢10个?,我们在Stack Overflow上找到一个类似的问题:https://stackoverflow.com/questions/42375003/

    10-09 01:49