java8 foreach性能分析_java 预加热模式-CSDN博客

本文链接：https://blog.csdn.net/embracelong/article/details/82979350

本文深入探讨了Java8中foreach方法的性能问题，通过对比传统for循环，分析了内部迭代器与外部迭代器的差异，揭示了性能损耗的主要原因在于Consumer的声明过程，并通过预热代码观察到JIT编译器的影响。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

研究java foreach性能引发的思考

根据阅读文章【java8】为java8的foreach正名引发思考，何为文章提到的预热代码。
正如文章所提到，目前很多性能测试分析得出结果java8 foreach的性能差，那为何oracle公司的开发人员没有考虑优化？
难道真的只是为了引入lambada语法对性能做了牺牲？那lambada的使用场景将十分局限。

生成的汇编代码

测试代码：

import java.util.ArrayList;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        List<String> test = new ArrayList<>();

        test.add("1");

        test.forEach(System.out::println);

        for (String s : test) {
            System.out.println(s);
        }
    }
}

生成的汇编语法

public class Main {
  public Main();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/util/ArrayList
       3: dup
       4: invokespecial #3                  // Method java/util/ArrayList."<init>":()V
       7: astore_1
       8: aload_1
       9: ldc           #4                  // String 1
      11: invokeinterface #5,  2            // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
      16: pop
      17: aload_1
      18: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
      21: dup
      22: invokevirtual #7                  // Method java/lang/Object.getClass:()Ljava/lang/Class;
      25: pop
      26: invokedynamic #8,  0              // InvokeDynamic #0:accept:(Ljava/io/PrintStream;)Ljava/util/function/Consumer;
      31: invokeinterface #9,  2            // InterfaceMethod java/util/List.forEach:(Ljava/util/function/Consumer;)V
      36: aload_1
      37: invokeinterface #10,  1           // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
      42: astore_2
      43: aload_2
      44: invokeinterface #11,  1           // InterfaceMethod java/util/Iterator.hasNext:()Z
      49: ifeq          72
      52: aload_2
      53: invokeinterface #12,  1           // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
      58: checkcast     #13                 // class java/lang/String
      61: astore_3
      62: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
      65: aload_3
      66: invokevirtual #14                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      69: goto          43
      72: return
}

注：idea如何配置查看汇编语法
忘了在哪看到有人回复说两者生成的机器语言是一样的，结果对比了下两者的汇编语法发现还是有差异的。
后来查看官方文档，发现这句话，我想说回复的同学应该是想表达官方的描述：
forEach vs for-loop
From a simple point of view, both loops provide the same functionality – loop through elements in a collection.
The main difference between the two of them is that they are different iterators – the enhanced for-loop is an external iterator whereas the new forEach method is an internal one.
从源码上来看，forEach也是在内部实现一个for loop，那问题是否在内部的迭代器和外部迭代器的差异呢。

External Iterator VS Internal Iterator

从实现上来说，两者没有特别大的差异，看各种文章都推崇内部迭代，主要是把控制交给类库，这样能实现外部迭代没法实现的一些功能，比如通过排序、并行、短路（short-circuiting）求值以及惰性求值改善性能。
那两者之间的性能差异又是有何而来，为何导致的呢？

java8 foreach引入了Consumer（动作）

是否是声明Consumer导致的时间开销？
新的测试方法：

import java.util.ArrayList;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        List<Integer> test = new ArrayList<>();

        for (int i = 0; i < 100000; i++) {
            test.add(i);
        }

        long l = System.currentTimeMillis();
        test.forEach(i -> {
        });
        System.out.println(System.currentTimeMillis() - l);

        l = System.currentTimeMillis();
        for (Integer s : test) {
        }
        System.out.println(System.currentTimeMillis() - l);
    }
}

这里发现无论test大小修改多大，loop和foreach都有个10倍的量级差，假设猜想这里的耗时差是在声明Consumer导致的，这时候修改代码：

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class Main {

    public static void main(String[] args) {
        List<Integer> test = new ArrayList<>();

        for (int i = 0; i < 100000; i++) {
            test.add(i);
        }

        long l = System.currentTimeMillis();
        Consumer<Integer> consumer = integer -> {
        };
        System.out.println(System.currentTimeMillis() - l);

        l = System.currentTimeMillis();
        test.forEach(consumer);
        System.out.println(System.currentTimeMillis() - l);

        l = System.currentTimeMillis();
        for (Integer s : test) {
        }
        System.out.println(System.currentTimeMillis() - l);
    }
}

这时候发现两个遍历耗时是相同的，10倍级别的耗时开销都在声明Consumer。
我们得到结论，其实foreach的开销都在声明Consumer，至于迭代器的实现，其实内部迭代和外部迭代就性能方面是没有差异的。

预加热是否优化了Consumer声明的时间开销

还是刚刚的测试代码：

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class Main {

    public static void main(String[] args) {
        List<Integer> test = new ArrayList<>();

        for (int i = 0; i < 100000; i++) {
            test.add(i);
        }

        long l = System.currentTimeMillis();
        Consumer<Integer> consumer = integer -> {
        };
        System.out.println(System.currentTimeMillis() - l);

        l = System.currentTimeMillis();
        Consumer<Integer> consumer1 = integer -> {
        };
        System.out.println(System.currentTimeMillis() - l);

        l = System.currentTimeMillis();
        Consumer<Integer> consumer2 = integer -> {
        };
        System.out.println(System.currentTimeMillis() - l);
    }
}

这时候发现第2、3次的时间开销远远小于第1次的时间开销，这时候做个猜想是否是JIT搞的鬼。
至此，对foreach性能差异引发的预加热分析至此告一段落，至于上诉所提是否是JIT的影响，在之后的文章继续分析。
最近终于把之前的想法付出行动，如：看jdk源码，写自己的博客等。这是第一篇博客，不喜勿怪。