当前位置: 首页 > 知识库问答 >
问题:

Java增强For循环比传统的更快?

陈飞语
2023-03-14

所以我的理解是,增强for循环应该更慢,因为它们必须使用迭代器。。然而,我的代码提供的结果参差不齐。。(是的,我知道循环逻辑占用了循环中的大部分时间)

对于较少的迭代次数(100-1000),无论有无JIT,增强的For循环似乎都要快得多。相反,对于大量迭代(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;
        }
    }
}

共有2个答案

屠盛
2023-03-14

这个问题有两个截然不同的问题。一个有效的观察结果是,在一个特定的程序中,迭代次数较少时,增强的for循环时间更快。另一个是对该观察结果的概括,即“对于较少的迭代次数(100-1000),无论有无JIT,增强的For循环似乎都要快得多。”

我看不出有任何理由这样概括。我对程序做了一个小改动,首先运行基本的for循环测试,然后运行增强的for循环。我还标记了输出,以减少处理修改版本时的混淆。以下是我对100次迭代的输出:

Warming up
Running
Enhanced For-Loop 2002nS
Basic For-Loop 70nS

按照原始顺序循环,我得到:

Warming up
Running
Basic For-Loop 2139nS
Enhanced For-Loop 137nS

如果我在运行第二个循环之前立即热身,而不是在开始时同时热身,我会得到:

Warming up
Running
Basic For-Loop 1093nS
Enhanced For-Loop 984nS

对于低迭代次数,结果非常依赖于程序的精细细节,微基准测试的固有危险,以及避免从单个程序观察推广到关于测量代码将如何执行的一般假设的原因任何其他程序

南宫云
2023-03-14

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

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

花点时间听这些演讲,并仔细阅读这些示例。

这就是使用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()vsiterator()的成本!

修复该问题:

@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()Iterator方法方面的幸运来解释,以及我们在这些内联之后可以享受的优化。

请注意indi_*测试,它否定了循环展开优化。尽管index在成功展开时具有更好的性能,但当展开中断时情况正好相反!

有了这样的标题,索引的和增强的之间的区别只不过是学术上的兴趣。为所有案例计算准确生成的代码(XX:PrintAssembly)留给读者练习:)

 类似资料:
  • 问题内容: 我读到 增强的for循环 比普通的 for循环 更有效: http://developer.android.com/guide/practices/performance.html#foreach 当我搜索它们的效率之间的差异时,我发现的是:如果是普通的for循环,我们需要一个额外的步骤来找出数组的长度或大小等, 但这是唯一的原因,增强的for循环优于普通的for循环吗?在那种情况下,

  • 问题内容: 我正在从Java切换到C ,并且想知道C 是否包含我在Java中使用的增强的for循环,例如: 在C ++中是否可能有相同的“快捷方式”? 问题答案: 在C ++ 11中,如果编译器支持,则可以。这称为基于范围的。 它适用于C样式数组以及具有函数并返回迭代器的任何类型。例:

  • 问题内容: 在玩循环的同时创建了以下代码。下面的代码将斐波那契值存储到数组中,然后使用for循环将其打印出来。 上面的代码工作正常。但是,第一次将它们放在一起时,我使用了增强的for循环来打印出值(代码中的第二个for循环)。可以很好地编译,但是运行时得到以下信息: 我不明白出了什么问题。更改第二个循环不应更改值(您会注意到斐波那契值是错误的(即缺少值))。而且我不明白为什么简单的增强型for循环

  • 问题内容: 我正在尝试找出部分任务,而现在我已经将头撞墙了。我正在尝试将DNA序列转录为RNA序列。但是,我正在获取ArrayOutOfBoundsException。我是使用增强的for循环进行迭代的新手,所以我的错误可能隐藏在某个地方。在满足if语句参数之前,它不会发生。 问题答案: 问题出在声明中 问题是内部表示为等于84,因此您得到一个。您需要使用传统计数器对其进行迭代:

  • 本文向大家介绍java增强for循环的实现方法,包括了java增强for循环的实现方法的使用技巧和注意事项,需要的朋友参考一下 如下所示: Map并没有实现Iterable接口,所以你不能直接使用增强for来遍历它! 以上就是小编为大家带来的java增强for循环的实现方法的全部内容了,希望对大家有所帮助,多多支持呐喊教程~

  • 问题内容: 我刚刚遇到了这个看似无害的评论,对ArrayList和原始String数组进行了基准测试。是几年前的事,但OP写道 我确实注意到,使用String:stringsList比使用旧式的for循环访问列表要慢大约50%。去搞清楚… 在原始帖子中没有人对此发表评论,并且该测试似乎有点可疑(太短了以至于不够准确),但是当我阅读它时,我几乎掉下了椅子。我从未针对“传统”循环对增强循环进行基准测试