Java 中的小型数组与列表的基准测试：我的基准测试代码是否错误？

Question

免责声明：我已经浏览过这个 问题和这个问题 但他们都被小事出轨了 细节和一般 优化是不必要的担忧。 我真的需要我所有的表现 可以进入我当前的应用程序，即 接收-处理-喷出 MIDI 数据 实时。还需要扩大规模 尽可能。

我将小列表的大量读取的array性能与ArrayList进行比较，并且还与仅将变量放在手。我发现数组优于 ArrayList 2.5 倍，甚至优于仅具有对象引用的数组。

我想知道的是：

1. 我的基准测试还好吗？ 我已经更改了测试顺序和运行次数，没有任何变化。我也使用毫秒而不是纳秒，但无济于事。
2. 我应该指定任何 Java 选项来最小化这种差异吗？
3. 如果这种差异确实存在，在这种情况下我不应该更喜欢 Test[] 而不是 ArrayList 在这种情况下并放入转换它们所需的代码？ 显然我读的比写的多。

JVM 是 OSX 上的 Java 1.6.0_17，并且它肯定运行在 Hotspot 模式下。

  public class ArraysVsLists {

    static int RUNS = 100000;

    public static void main(String[] args) {
        long t1;
        long t2;

        Test test1 = new Test();
        test1.thing = (int)Math.round(100*Math.random());
        Test test2 = new Test();
        test2.thing = (int)Math.round(100*Math.random());

        t1 = System.nanoTime();

        for (int i=0; i<RUNS; i++) {
            test1.changeThing(i);
            test2.changeThing(i);
        }

        t2 = System.nanoTime();
        System.out.println((t2-t1) + " How long NO collection");

        ArrayList<Test> list = new ArrayList<Test>(1);
        list.add(test1);
        list.add(test2);
        // tried this too: helps a tiny tiny bit 
        list.trimToSize();

        t1= System.nanoTime();

        for (int i=0; i<RUNS; i++) {
            for (Test eachTest : list) {
                eachTest.changeThing(i);
            }
        }

        t2 = System.nanoTime();
        System.out.println((t2-t1) + " How long collection");


        Test[] array = new Test[2];
        list.toArray(array);

        t1= System.nanoTime();

        for (int i=0; i<RUNS; i++) {
            for (Test test : array) {
                test.changeThing(i);
            }
        }

        t2 = System.nanoTime();
        System.out.println((t2-t1) + " How long array ");

    }
}

class Test {
    int thing;
    int thing2;
    public void changeThing(int addThis) {
        thing2 = addThis + thing;
    }
}

Answer 1

在 Java 这样的平台上获得正确的微基准测试非常非常困难。您肯定必须将要进行基准测试的代码提取到单独的方法中，作为预热运行它们几千次，然后进行测量。我已经这样做了（下面的代码），结果是通过引用的直接访问速度是通过数组的三倍，但集合仍然慢了 2 倍。

这些数字基于 JVM 选项 <代码>-server -XX:+DoEscapeAnalysis。如果没有 -server，使用集合会大大变慢（但奇怪的是，直接访问和数组访问要快得多，这表明发生了一些奇怪的事情）。 -XX:+DoEscapeAnalysis 为集合带来了另外 30% 的加速，但它是否适用于您的实际生产代码是非常值得怀疑的。

总的来说，我的结论是：忘记微基准，它们很容易产生误导。尽可能接近生产代码进行测量，而无需重写整个应用程序。

import java.util.ArrayList;

public class ArrayTest {

    static int RUNS_INNER = 1000;
    static int RUNS_WARMUP = 10000;
    static int RUNS_OUTER = 100000;

    public static void main(String[] args) {
        long t1;
        long t2;

        Test test1 = new Test();
        test1.thing = (int)Math.round(100*Math.random());
        Test test2 = new Test();
        test2.thing = (int)Math.round(100*Math.random());

        for(int i=0; i<RUNS_WARMUP; i++)
        {
            testRefs(test1, test2);            
        }
        t1 = System.nanoTime();
        for(int i=0; i<RUNS_OUTER; i++)
        {
            testRefs(test1, test2);            
        }

        t2 = System.nanoTime();
        System.out.println((t2-t1)/1000000.0 + " How long NO collection");

        ArrayList<Test> list = new ArrayList<Test>(1);
        list.add(test1);
        list.add(test2);
        // tried this too: helps a tiny tiny bit 
        list.trimToSize();

        for(int i=0; i<RUNS_WARMUP; i++)
        {
            testColl(list);
        }
        t1= System.nanoTime();

        for(int i=0; i<RUNS_OUTER; i++)
        {
            testColl(list);
        }

        t2 = System.nanoTime();
        System.out.println((t2-t1)/1000000.0 + " How long collection");


        Test[] array = new Test[2];
        list.toArray(array);

        for(int i=0; i<RUNS_WARMUP; i++)
        {
            testArr(array);            
        }
        t1= System.nanoTime();

        for(int i=0; i<RUNS_OUTER; i++)
        {
            testArr(array);
        }

        t2 = System.nanoTime();
        System.out.println((t2-t1)/1000000.0 + " How long array ");

    }

    private static void testArr(Test[] array)
    {
        for (int i=0; i<RUNS_INNER; i++) {
            for (Test test : array) {
                test.changeThing(i);
            }
        }
    }

    private static void testColl(ArrayList<Test> list)
    {
        for (int i=0; i<RUNS_INNER; i++) {
            for (Test eachTest : list) {
                eachTest.changeThing(i);
            }
        }
    }

    private static void testRefs(Test test1, Test test2)
    {
        for (int i=0; i<RUNS_INNER; i++) {
            test1.changeThing(i);
            test2.changeThing(i);
        }
    }
}

class Test {
    int thing;
    int thing2;
    public void changeThing(int addThis) {
        thing2 = addThis + thing;
    }
}

Answer 2

仅当您的实际用例与基准代码匹配时，您的基准测试才有效，即每个元素上的操作很少，因此执行时间很大程度上取决于访问时间而不是操作本身。如果是这种情况，那么是的，如果性能至关重要，您应该使用数组。然而，如果您的实际用例涉及每个元素更多的实际计算，那么每个元素的访问时间将变得不那么重要。

Answer 3

它可能无效。如果我了解 JIT 编译器的工作方式，编译方法不会影响对已执行的该方法的调用。由于 main 方法仅被调用一次，因此它最终会被解释，并且由于大部分工作是在该方法的主体中完成的，因此您得到的数字不会特别指示正常情况执行。

JIT 编译效果可能在某种程度上解释了为什么没有集合的情况比数组的情况慢。这个结果是违反直觉的，并且它对您报告的其他基准结果产生了疑问。