System.arrayCopy 很慢

我一直在尝试测量 System.arrayCopy 与 Arrays.copyOf 的性能，以便正确选择其中之一。只是为了基准测试，我还添加了手动复制，结果令我惊讶。 显然我错过了一些非常重要的东西，你能告诉我它是什么吗？实现如下（见前4种方法）。

public class ArrayCopy {

    public static int[] createArray( int size ) {
        int[] array = new int[size];
        Random r = new Random();
        for ( int i = 0; i < size; i++ ) {
            array[i] = r.nextInt();
        }
        return array;
    }

    public static int[] copyByArraysCopyOf( int[] array, int size ) {
        return Arrays.copyOf( array, array.length + size );
    }

    public static int[] copyByEnlarge( int[] array, int size ) {
        return enlarge( array, size );
    }

    public static int[] copyManually( int[] array, int size ) {
        int[] newArray = new int[array.length + size];
        for ( int i = 0; i < array.length; i++ ) {
            newArray[i] = array[i];
        }
        return newArray;
    }

    private static void copyArray( int[] source, int[] target ) {
        System.arraycopy( source, 0, target, 0, Math.min( source.length, target.length ) );
    }

    private static int[] enlarge( int[] orig, int size ) {
        int[] newArray = new int[orig.length + size];
        copyArray( orig, newArray );
        return newArray;
    }

    public static void main( String... args ) {
        int[] array = createArray( 1000000 );
        int runs = 1000;
        int size = 1000000;
        System.out.println( "****************** warm up #1 ******************" );
        warmup( ArrayCopy::copyByArraysCopyOf, array, size, runs );
        warmup( ArrayCopy::copyByEnlarge, array, size, runs );
        warmup( ArrayCopy::copyManually, array, size, runs );
        System.out.println( "****************** warm up #2 ******************" );
        warmup( ArrayCopy::copyByArraysCopyOf, array, size, runs );
        warmup( ArrayCopy::copyByEnlarge, array, size, runs );
        warmup( ArrayCopy::copyManually, array, size, runs );
        System.out.println( "********************* test *********************" );
        System.out.print( "copyByArrayCopyOf" );
        runTest( ArrayCopy::copyByArraysCopyOf, array, size, runs );
        System.out.print( "copyByEnlarge" );
        runTest( ArrayCopy::copyByEnlarge, array, size, runs );
        System.out.print( "copyManually" );
        runTest( ArrayCopy::copyManually, array, size, runs );
    }

    private static void warmup( BiConsumer<int[], Integer> consumer, int[] array, int size, int runs ) {
        for ( int i = 0; i < runs; i++ ) {
            consumer.accept( array, size );
        }
    }

    private static void runTest( BiConsumer<int[], Integer> consumer, int[] array, int size, int runs ) {
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        long currentCpuTime = threadMXBean.getCurrentThreadCpuTime();
        long nanoTime = System.nanoTime();
        for ( int i = 0; i < runs; i++ ) {
            consumer.accept( array, size );
        }
        System.out.println( "-time = " + ( ( System.nanoTime() - nanoTime ) / 10E6 ) + " ms. CPU time = " + ( ( threadMXBean.getCurrentThreadCpuTime() - currentCpuTime ) / 10E6 ) + " ms" );
    }
}

结果显示，手动复制的性能提高了 30% 左右，如下所示：

****************** warm up #1 ******************
****************** warm up #2 ******************
********************* test *********************
copyByArrayCopyOf-time = 162.470107 ms. CPU time = 153.125 ms
copyByEnlarge-time = 168.6757949 ms. CPU time = 164.0625 ms
copyManually-time = 116.3975962 ms. CPU time = 110.9375 ms

我真的很困惑，因为我认为（可能现在仍然如此）System.arrayCopy由于它的诞生是复制数组的最佳方法，但我无法解释这个结果。

实际上，HotSpot 编译器足够智能，可以展开和矢量化手动复制循环 - 这就是结果代码似乎得到了很好优化的原因。

Why is System.arraycopy那么慢一点？它本来就是一个本地方法，你必须为本地调用付费，直到编译器将其优化为 JVM 内在方法。

但是，在您的测试中，编译器没有机会进行此类优化，因为enlarge方法被调用的次数不够多（即它不被认为是热的）。

我将向您展示一个强制优化的有趣技巧。改写enlarge方法如下：

private static int[] enlarge(int[] array, int size) {
    for (int i = 0; i < 10000; i++) { /* fool the JIT */ }

    int[] newArray = new int[array.length + size];
    System.arraycopy(array, 0, newArray, 0, array.length);
    return newArray;
}

空循环会触发后沿计数器溢出，进而触发编译enlarge方法。然后，空循环就会从编译的代码中消除，因此它是无害的。现在enlarge方法得到关于速度提高 1.5 倍比手动循环！

重要的是System.arraycopy紧随其后new int[]。在这种情况下，HotSpot 可以优化掉新分配数组的冗余归零。您知道，所有 Java 对象在创建后都必须立即清零。但只要编译器检测到数组在创建后立即被填充，它可能会消除归零，从而使结果代码更快。

P.S.@assylias 的基准很好，但它也受到以下事实的影响：System.arraycopy对于大型数组来说不是内在化的。如果数组较小arrayCopy每秒调用多次基准测试，JIT 认为它很热并且优化得很好。但对于大型数组，每次迭代的时间较长，因此每秒的迭代次数要少很多，并且 JIT 不处理arrayCopy as hot.