Java 增强型 For-Loop 比传统的更快？

所以我的理解是，增强的 for 循环应该更慢，因为它们必须使用迭代器。但是我的代码提供了混合结果。（是的，我知道循环逻辑占用了循环中花费的大部分时间）

对于少量迭代（100-1000），增强的 for 循环在使用和不使用 JIT 的情况下似乎都要快得多。相反，当迭代次数较多（100000000 次）时，传统循环要快得多。这里发生了什么？

public class NewMain {

    public static void main(String[] args) {

        System.out.println("Warming up");

        int warmup = 1000000;
        for (int i = 0; i < warmup; i++) {
            runForLoop();
        }
        for (int i = 0; i < warmup; i++) {
            runEnhancedFor();
        }

        System.out.println("Running");
        int iterations = 100000000;
        long start = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            runForLoop();
        }
        System.out.println((System.nanoTime() - start) / iterations + "nS");

        start = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            runEnhancedFor();
        }
        System.out.println((System.nanoTime() - start) / iterations + "nS");
    }

    public static final List<Integer> array = new ArrayList(100);

    public static int l;

    public static void runForLoop() {
        for (int i = 0; i < array.size(); i++) {
            l += array.get(i);
        }
    }

    public static void runEnhancedFor() {
        for (int i : array) {
            l += i;
        }
    }
}

基准测试错误。错误的非详尽列表：

• 没有适当的热身：单次测量几乎总是错误的；
• 在单个方法中混合多个代码路径：我们可能开始使用仅适用于方法中第一个循环的执行数据来编译该方法；
• 来源是可预测的：如果循环编译，我们实际上可以预测结果；
• 结果已消除死代码：如果循环可以编译，我们可以扔掉循环

花点时间听这些谈话 http://shipilev.net/pub/#benchmarking，并经过这些样本 http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/.

这就是你可以说正确的做法jmh:

@OutputTimeUnit(TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Warmup(iterations = 3, time = 1)
@Measurement(iterations = 3, time = 1)
@Fork(3)
@State(Scope.Thread)
public class EnhancedFor {

    private static final int SIZE = 100;

    private List<Integer> list;

    @Setup
    public void setup() {
        list = new ArrayList<Integer>(SIZE);
    }


    @GenerateMicroBenchmark
    public int enhanced() {
        int s = 0;
        for (int i : list) {
            s += i;
        }
        return s;
    }

    @GenerateMicroBenchmark
    public int indexed() {
        int s = 0;
        for (int i = 0; i < list.size(); i++) {
            s += list.get(i);
        }
        return s;
    }

    @GenerateMicroBenchmark
    public void enhanced_indi(BlackHole bh) {
        for (int i : list) {
            bh.consume(i);
        }
    }

    @GenerateMicroBenchmark
    public void indexed_indi(BlackHole bh) {
        for (int i = 0; i < list.size(); i++) {
            bh.consume(list.get(i));
        }
    }

}

...这会产生以下内容：

Benchmark                         Mode   Samples      Mean   Mean error    Units
o.s.EnhancedFor.enhanced          avgt         9     8.162        0.057    ns/op
o.s.EnhancedFor.enhanced_indi     avgt         9     7.600        0.067    ns/op
o.s.EnhancedFor.indexed           avgt         9     2.226        0.091    ns/op
o.s.EnhancedFor.indexed_indi      avgt         9     2.116        0.064    ns/op

现在，增强循环和索引循环之间存在微小差异，并且通过采用不同的代码路径来访问后备存储来简单地解释这种差异。然而，解释实际上要简单得多：OP 忘记填写列表，这意味着循环体从未被执行过，而基准实际上是衡量成本size() vs iterator()!

解决这个问题：

@Setup
public void setup() {
    list = new ArrayList<Integer>(SIZE);
    for (int c = 0; c < SIZE; c++) {
        list.add(c);
    }
}

...然后产生：

Benchmark                         Mode   Samples       Mean   Mean error    Units
o.s.EnhancedFor.enhanced          avgt         9    171.154       25.892    ns/op
o.s.EnhancedFor.enhanced_indi     avgt         9    384.192        6.856    ns/op
o.s.EnhancedFor.indexed           avgt         9    148.679        1.357    ns/op
o.s.EnhancedFor.indexed_indi      avgt         9    465.684        0.860    ns/op

请注意，即使在纳米尺度上，差异也非常微小，并且非平凡的循环体将消耗差异（如果有）。这里的差异可以用我们内联的幸运来解释get() and Iterator方法，以及我们在这些内联之后可以享受的优化。

请注意indi_*测试，这会否定循环展开优化。虽然indexed成功展开时性能更好，但展开失败时则相反！

有了这样的标题，之间的区别indexed and enhanced无非是学术兴趣。找出确切生成的代码-XX:+PrintAssembly所有案例都留给读者作为练习:)