为什么字节加法性能如此不可预测？

你的结果的原因是你实际上并不知道你在测量什么。Java的即时编译器肯定会查看您的代码，并且可能只是碰巧您没有测量任何内容。

编译器足够聪明，可以弄清楚你实际上并没有用于任何事情。因此，它最终将从正在运行的应用程序中删除所有相关代码。因此，您的基准测试最有可能衡量一个越来越空的应用程序。List<byte[]>

所有这些问题的答案始终是：在我们实际查看有效的基准之前，不值得进行讨论。像JMH（我可以推荐）这样的基准测试工具知道一个叫做黑洞的概念。黑洞旨在混淆实时编译器，以便认为计算值实际上用于某些事情，即使它不是。有了这样的黑洞，否则被擦除为no-op的代码将保留下来。

自行开发的基准测试的另一个典型问题是优化的循环。同样，实时编译器将注意到循环对任何迭代产生相同的计算，因此将完全删除该循环。使用（质量）基准测试工具，您只会建议运行多个循环，而不是对它们进行硬编码。这样，工具就可以处理欺骗编译器的问题。

用JMH写一个基准测试，你会看到你测量的时间会大不相同。

关于你的更新：我只能重复我自己。永远不要相信一个不受伤害的基准！了解 JVM 对代码执行的操作的一种简单方法是运行 JITwatch。基准测试的主要问题是它忽略了 JVM 的分析。概要文件是 JVM 尝试记住代码的属性，然后基于这些属性进行优化。对于基准测试，您将不同运行的配置文件混合在一起。然后，JVM 必须更新其当前配置文件并动态重新编译字节代码，这需要花费时间。

为了避免这个问题，像JMH这样的工具允许你为每个基准测试分叉一个JVM新进程。以下是我用一个定制的基准来衡量的内容：

Benchmark                    Mode   Samples         Mean   Mean error    Units
o.s.MyBenchmark.test100k     avgt        20     1922.671       29.155    ns/op
o.s.MyBenchmark.test10k      avgt        20     1911.152       13.217    ns/op
o.s.MyBenchmark.test1k       avgt        20     1857.205        3.086    ns/op
o.s.MyBenchmark.test200k     avgt        20     1905.360       18.102    ns/op
o.s.MyBenchmark.test25k      avgt        20     1832.663      102.562    ns/op
o.s.MyBenchmark.test50k      avgt        20     1907.488       18.043    ns/op

以下是基于上述 JMH 的基准测试的源代码：

@State(Scope.Benchmark)
public class MyBenchmark {

    private List<byte[]> input1k, input10k, input25k, input50k, input100k, input200k;

    @Setup
    public void setUp() {
        input1k = createByteArray(1_000);
        input10k = createByteArray(10_000);
        input25k = createByteArray(25_000);
        input50k = createByteArray(50_000);
        input100k = createByteArray(100_000);
        input200k = createByteArray(200_000);
    }

    private static List<byte[]> createByteArray(int length) {
        Random random = new Random();
        List<byte[]> resultList = new ArrayList<>();
        for (int i = 0; i < length; i++) {
            byte[] byteArray = new byte[4096];
            byteArray[random.nextInt(4096)] = 1;
            resultList.add(byteArray);
        }
        return resultList;
    }

    @GenerateMicroBenchmark
    @BenchmarkMode(Mode.AverageTime)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    @OperationsPerInvocation(1_000)
    public boolean test1k() {
        return runBenchmark(input1k, this::byteArrayCheck);
    }

    @GenerateMicroBenchmark
    @BenchmarkMode(Mode.AverageTime)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    @OperationsPerInvocation(10_000)
    public boolean test10k() {
        return runBenchmark(input10k, this::byteArrayCheck);
    }

    @GenerateMicroBenchmark
    @BenchmarkMode(Mode.AverageTime)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    @OperationsPerInvocation(25_000)
    public boolean test25k() {
        return runBenchmark(input25k, this::byteArrayCheck);
    }

    @GenerateMicroBenchmark
    @BenchmarkMode(Mode.AverageTime)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    @OperationsPerInvocation(50_000)
    public boolean test50k() {
        return runBenchmark(input50k, this::byteArrayCheck);
    }

    @GenerateMicroBenchmark
    @BenchmarkMode(Mode.AverageTime)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    @OperationsPerInvocation(100_000)
    public boolean test100k() {
        return runBenchmark(input100k, this::byteArrayCheck);
    }

    @GenerateMicroBenchmark
    @BenchmarkMode(Mode.AverageTime)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    @OperationsPerInvocation(200_000)
    public boolean test200k() {
        return runBenchmark(input200k, this::byteArrayCheck);
    }

    private static boolean runBenchmark(List<byte[]> arrays, Predicate<byte[]> method) {
        boolean someUnrelatedResult = false;
        for (byte[] array : arrays) {
            someUnrelatedResult |= method.test(array);
        }
        return someUnrelatedResult;
    }

    private boolean byteArrayCheck(final byte[] array) {
        long sum = 0L;
        for (byte b : array) {
            sum += b;
        }
        return (sum == 0);
    }

    public static void main(String[] args) throws RunnerException {
        new Runner(new OptionsBuilder()
                .include(".*" + MyBenchmark.class.getSimpleName() + ".*")
                .forks(1)
                .build()).run();
    }
}

对于 1000 次迭代，您只是测量方法调用的开销、测量时间等，这超过了执行实际工作的时间。超过 50，000 次迭代，您的处理器耗尽了 L1 缓存并速度变慢。根据处理器的缓存大小，当数据不再适合 L2 缓存时，您可能会在几百万次迭代时再次减速。

您的处理器具有8MB的缓存，因此在该迭代次数下，您应该会降低下一个速度。您可以通过仅每四个字节添加 say 来更改测试，并且您会发现您的时间没有改善，因为花费时间的不是操作，而是内存带宽。