java – System.arrayCopy很慢

发布时间：2020-12-15 00:58:09 所属栏目：Java 来源：网络整理

导读：我一直在努力测量System.arrayCopy vs Arrays.copyOf的性能,以便正确选择其中之一.只是为了基准,我添加了手动拷贝,结果令我惊讶. 显然我错过了一些非常重要的东西,可以请告诉我,它是什么？实现如下(见前4种方法). public class ArrayCopy { public static in

我一直在努力测量System.arrayCopy vs 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,target,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,runs );
        warmup( ArrayCopy::copyManually,runs );
        System.out.println( "****************** warm up #2 ******************" );
        warmup( ArrayCopy::copyByArraysCopyOf,runs );
        System.out.println( "********************* test *********************" );
        System.out.print( "copyByArrayCopyOf" );
        runTest( ArrayCopy::copyByArraysCopyOf,runs );
        System.out.print( "copyByEnlarge" );
        runTest( ArrayCopy::copyByEnlarge,runs );
        System.out.print( "copyManually" );
        runTest( ArrayCopy::copyManually,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[],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编译器足够聪明地展开和向量化手动复制循环 – 这就是为什么结果代码看起来被很好的优化.

为什么System.arraycopy更慢？它最初是一种本机方法,您必须支付本机调用,直到编译器将其优化为JVM内在函数.

然而,在测试中,编译器没有机会进行这种优化,因为放大方法不被称为很多次(即不被认为是热).

我会给你一个有趣的技巧来强制优化.重写放大法如下：

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,newArray,array.length);
    return newArray;
}

空循环触发反向计数器溢出,这反过来触发了放大方法的编译.然后从编译的代码中消除空循环,因此它是无害的.现在的放大方法比手动循环快约1.5倍！

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

附： @assylias’的基准是好的,但也是因为System.arraycopy并没有为大数组内化的事实.在小数组的情况下,ArrayCopy基准测试每秒调用多次,JIT认为它很热,并能很好地优化.但是,对于大型阵列,每次迭代都会更长,因此每秒重复次数少得多,JIT不会将arrayCopy视为热.

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!