为什么小数组的 Arrays.copyOf 比 System.arraycopy 快 2 倍？

Question

我最近在玩一些基准测试，发现非常有趣的结果，我现在无法解释。这是基准：

@BenchmarkMode(Mode.Throughput)
@Fork(1)
@State(Scope.Thread)
@Warmup(iterations = 10, time = 1, batchSize = 1000)
@Measurement(iterations = 10, time = 1, batchSize = 1000)
public class ArrayCopy {

    @Param({"1","5","10","100", "1000"})
    private int size;
    private int[] ar;

    @Setup
    public void setup() {
        ar = new int[size];
        for (int i = 0; i < size; i++) {
            ar[i] = i;
        }
    }

    @Benchmark
    public int[] SystemArrayCopy() {
        final int length = size;
        int[] result = new int[length];
        System.arraycopy(ar, 0, result, 0, length);
        return result;
    }

    @Benchmark
    public int[] javaArrayCopy() {
        final int length = size;
        int[] result = new int[length];
        for (int i = 0; i < length; i++) {
            result[i] = ar[i];
        }
        return result;
    }

    @Benchmark
    public int[] arraysCopyOf() {
        final int length = size;
        return Arrays.copyOf(ar, length);
    }

}

结果：

Benchmark                  (size)   Mode  Cnt       Score      Error  Units
ArrayCopy.SystemArrayCopy       1  thrpt   10   52533.503 ± 2938.553  ops/s
ArrayCopy.SystemArrayCopy       5  thrpt   10   52518.875 ± 4973.229  ops/s
ArrayCopy.SystemArrayCopy      10  thrpt   10   53527.400 ± 4291.669  ops/s
ArrayCopy.SystemArrayCopy     100  thrpt   10   18948.334 ±  929.156  ops/s
ArrayCopy.SystemArrayCopy    1000  thrpt   10    2782.739 ±  184.484  ops/s
ArrayCopy.arraysCopyOf          1  thrpt   10  111665.763 ± 8928.007  ops/s
ArrayCopy.arraysCopyOf          5  thrpt   10   97358.978 ± 5457.597  ops/s
ArrayCopy.arraysCopyOf         10  thrpt   10   93523.975 ± 9282.989  ops/s
ArrayCopy.arraysCopyOf        100  thrpt   10   19716.960 ±  728.051  ops/s
ArrayCopy.arraysCopyOf       1000  thrpt   10    1897.061 ±  242.788  ops/s
ArrayCopy.javaArrayCopy         1  thrpt   10   58053.872 ± 4955.749  ops/s
ArrayCopy.javaArrayCopy         5  thrpt   10   49708.647 ± 3579.826  ops/s
ArrayCopy.javaArrayCopy        10  thrpt   10   48111.857 ± 4603.024  ops/s
ArrayCopy.javaArrayCopy       100  thrpt   10   18768.866 ±  445.238  ops/s
ArrayCopy.javaArrayCopy      1000  thrpt   10    2462.207 ±  126.549  ops/s

所以这里有两个奇怪的地方：

• Arrays.copyOf 比 System.arraycopy 快 2 倍 数组（1,5,10 大小）。但是，在大小为 1000 的大型数组上 Arrays.copyOf 几乎慢了 2 倍。我知道两者 方法是内在函数，所以我期望相同的性能。在哪里 这种差异是从哪里来的？
• 1 元素数组的手动复制比System.arraycopy 快。我不清楚为什么。有人知道吗？

虚拟机版本：JDK 1.8.0_131，虚拟机 25.131-b11

Answer 1

您的System.arraycopy 基准在语义上不等同于Arrays.copyOf。

如果你替换它会是

    System.arraycopy(ar, 0, result, 0, length);

与

    System.arraycopy(ar, 0, result, 0, Math.min(ar.length, length));

随着这一变化，两个基准的性能也将变得相似。

那么为什么第一个变种更慢？

1. 在不知道length 与ar.length 的关系的情况下，JVM 需要执行额外的边界检查并准备在length > ar.length 时抛出IndexOutOfBoundsException。

2. 这也破坏了消除冗余归零的优化。你知道，每个分配的数组都必须用零初始化。但是，如果 JIT 在创建后立即看到数组已填充，则可以避免归零。但是-prof perfasm 清楚地表明，原始的System.arraycopy 基准测试花费了大量时间来清除分配的数组：

    0,84%    0x000000000365d35f: shr    $0x3,%rcx
    0,06%    0x000000000365d363: add    $0xfffffffffffffffe,%rcx
    0,69%    0x000000000365d367: xor    %rax,%rax
             0x000000000365d36a: shl    $0x3,%rcx
   21,02%    0x000000000365d36e: rep rex.W stos %al,%es:(%rdi)  ;*newarray
   

对于小型数组，手动复制似乎更快，因为与 System.arraycopy 不同，它不会对 VM 函数执行任何运行时调用。