"背景 大家都知道,在写循环语句时有个优化技巧就是将条件计算尽量放到循环外部,避免每次循环时触发不必要的调用和计算,比如将 for (int i = 0; i < s.length(); i++) { // .... } 优化为: int len = s.length(); for (int i ...."

谜之 Loop 性能优化

背景

大家都知道,在写循环语句时有个优化技巧就是将条件计算尽量放到循环外部,避免每次循环时触发不必要的调用和计算,比如将

for (int i = 0; i < s.length(); i++) {
    // ....
}

优化为:

int len = s.length();
for (int i = 0; i < len; i++) {
    // ....
}

问题

有了以上的优化技巧, 你对下面代码的执行结果预期是 innerLen 更快还是 outerLen 更快呢?

package test;

import java.util.HashSet;
import java.util.Set;

public class Loop {

    public static void main(String[] args) throws Exception {
        String str = "dummy";

        for (int i = 0; i < 25; i++) {
            str += str;
        }

        System.out.println("len: " + str.length());

        System.out.print("inner: ");
        final long startInner = System.currentTimeMillis();
        innerLen(str);
        System.out.println(System.currentTimeMillis() - startInner);

        System.out.print("outer: ");
        final long startOuter = System.currentTimeMillis();
        outerLen(str);
        System.out.println(System.currentTimeMillis() - startOuter);
    }

    public static void outerLen(final String s) {
        final Set<String> set = new HashSet<>();

        final int len = s.length();
        for (int i = 0; i < len; i++) {
            set.add("i");
        }
    }

    public static void innerLen(final String s) {
        final Set<String> set = new HashSet<>();

        for (int i = 0; i < s.length(); i++) {
            set.add("i");
        }
    }
}

如果你也得到和我类似的结果(inner 更快):

len: 167772160
inner: 352
outer: 480

握个爪先,我们来分析分析。

反汇编

因为 JVM 的强大,很多时候我们都会觉得:“是不是编译器偷偷做了什么优化导致结果反常?”带着这个疑问,我们就先看下字节码文件反汇编出来的结果:

C:\Users\s\Documents\NetBeansProjects\Test\build\classes>javap -c test\Loop.class
Compiled from "Loop.java"
public class test.Loop {
  public test.Loop();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]) throws java.lang.Exception;
    Code:
       略过

  public static void outerLen(java.lang.String);
    Code:
       0: new           #19                 // class java/util/HashSet
       3: dup
       4: invokespecial #20                 // Method java/util/HashSet."<init>":()V
       7: astore_1
       8: aload_0
       9: invokevirtual #9                  // Method java/lang/String.length:()I
      12: istore_2                          // len 结果保存在变量 2 中
      13: iconst_0                          // 将整型值 0 入栈
      14: istore_3                          // 出栈并存入变量 3 中
      15: iload_3                           // 载入变量 3(循环开始,i = 0)
      16: iload_2                           // 载入变量 2,即 len
      17: if_icmpge     35                  // 变量 3 大于等于变量 2 的话跳到 35(结束循环) 
      20: aload_1                            
      21: ldc           #21                 // String i
      23: invokeinterface #22,  2           // InterfaceMethod java/util/Set.add:(Ljava/lang/Object;)Z
      28: pop
      29: iinc          3, 1                // 变量 3 自加 1
      32: goto          15
      35: return

  public static void innerLen(java.lang.String);
    Code:
       0: new           #19                 // class java/util/HashSet
       3: dup
       4: invokespecial #20                 // Method java/util/HashSet."<init>":()V
       7: astore_1
       8: iconst_0
       9: istore_2
      10: iload_2
      11: aload_0
      12: invokevirtual #9                  // Method java/lang/String.length:()I
      15: if_icmpge     33
      18: aload_1
      19: ldc           #21                 // String i
      21: invokeinterface #22,  2           // InterfaceMethod java/util/Set.add:(Ljava/lang/Object;)Z
      26: pop
      27: iinc          2, 1
      30: goto          10
      33: return
}

outerLen 的 15-32 是循环部分,innerLen 的 10-30 是循环部分。我们可以清晰看到 innerLen 在循环中调用了 String#length() 方法,所以理论上它的耗时是会更多的。

那为什么还会出现 innerLen 耗时更短的现象呢?

更多的测试

编译器永远是对的,代码也没看出来问题,那就是测试方式不对了?

加入多种测试方式并记录结果:

  • 重复 10 次运行,发现全部都是 innerLen
  • 通过调换 outerLeninnerLen 执行顺序(让 outerLen 先跑),我们发现结果逆转了,outerLen 终于符合预期,更快了
  • 同一次运行中加入重复次数

      for (int i = 0; i < 10; i++) {
          System.out.print("inner: ");
          long startInner = System.currentTimeMillis();
          innerLen(str);
          System.out.println(System.currentTimeMillis() - startInner);
    
          System.out.print("outer: ");
          long startOuter = System.currentTimeMillis();
          outerLen(str);
          System.out.println(System.currentTimeMillis() - startOuter);
    
          System.out.println("----");
      }
    

    发现除了第一次是 innerLen 快,其余 9 次均是 outerLen 快,这 9 次符合预期

看来问题是因为 JVM 某种“动态”因素决定的,这个因素很可能和 GC 有关。


未完待续....

2     3     0     1     0    
41 回帖  
  • Zephyr • 4 个月前

    outter更快,难不成……?

    0   0   0  
  • mainlove • 4 个月前

    length 没有被计算 只是不停的调的引用。。。。。

    广义上没区别。。。

    0   0   0  
  • zonghua • 4 个月前

    for(int i = 0; i < a.length(); i++ )
        // TODO
    

    其实里面的方法是一直在调用的嘛???

    1 回复 0   0   0  
  • 88250 • 4 个月前

    a.length() 肯定会被调用的。

    1 回复 0   0   0  
  • zonghua • 4 个月前

    public class Loop {
        public static void main(String[] args) {
            for(int i=0;i<length();i++){
                D.d("loop "+i);
            }
        }
    
        static int length(){
            D.d("get length");
            return 200;
        }
    }
    

    运行

    get length
    loop 196
    get length
    loop 197
    get length
    loop 198
    get length
    loop 199
    get length
    

    这个很值得注意一下啊

    1 回复 0   0   0  
  • 88250 • 4 个月前

    回归本题,innerLen 快还是 outerLen 快,跑个结果看下么?

    1 回复 0   0   0  
  • zonghua • 4 个月前

    顺便测试一下泛型的影响

    0   0   0  
  • zonghua • 4 个月前

    len: 167772160
    inner: 782
    outer: 662
    

    1 回复 0   0   0  
  • 88250 • 4 个月前

    你的 JDK 是 1.7 还是 1.8?

    2 回复 0   0   0  
  • zonghua • 4 个月前

    1.8

    1 回复 0   0   0  
  • 88250 • 4 个月前

    我这里的结果:

    len: 167772160
    inner: 341
    outer: 499
    

    并且如果调换一下顺序,让 outer 先执行,那么就会变成 outer 更快,难道是后者会发生 gc 而耗时更长?

    2 回复 0   0   0  
  • zonghua • 4 个月前

    奇怪了啊

    0   0   0  
  • zonghua • 4 个月前

    割草要一百毫秒嘛

    0   0   0  
  • zonghua • 4 个月前

    1475053395521

    怎么指定 main

    1 回复 0   0   0  
  • 88250 • 4 个月前

    这个问题自己解决吧 :p

    0   0   0  
  • Hassan • 4 个月前

    分开两个 main 跑,结果差不多。有时 inner 比 outer 大,有时又小。
    看似区别不大,可能是因为 java.lang.String#length 是直接返回值,可以忽略。一点差异应该和当时的机器环境有关系。但是,总觉得 outer 写法总是没错的。万一这个length/size,条件什么的,调用很慢,影响肯定很大。

    PS:你这个25调了多少次? 是不是写完发现内存不够,才调到25的?哈哈。
    PPS:你们机器都好,我公司破电脑,都输出都2000多。

    1 回复 1   0   0  
  • Angonger • 4 个月前

    我调到30都内存不够

    1 回复 0   0   0  
  • senowang • 4 个月前

    len: 167772160
    inner: 1226
    outer: 1249

    0   0   0  
  • senowang • 4 个月前

    @88250
    public static void innerLen1(String s) {
    Set set = new HashSet<>();
    for (int i = 0,length=s.length(); i < length; i++) {
    set.add("i");
    }
    }
    我发现这样更快
    len: 167772160
    outer: 1184
    inner: 1064
    inner1: 956

    1 回复 0   0   0  
  • senowang • 4 个月前

    其实花费的时间很多都在hashSet 的扩容上面 如果将代码改下
    Set set = new HashSet<>(s.length());
    试试结果如何

    1 回复 0   0   0  
  • 88250 • 4 个月前

    set 不会被扩容的

    2 回复 0   0   0  
  • senowang • 4 个月前

    /**

       * Constructs a new, empty set; the backing HashMap  instance has
       * the specified initial capacity and default load factor (0.75). * * @param initialCapacity the initial capacity of the hash table
       * @throws IllegalArgumentException if the initial capacity is less
       *             than zero */public HashSet(int initialCapacity) {
          map = new HashMap<>(initialCapacity);
      }
      @<a href='https://hacpai.com/member/88250'>88250</a> 你不会说map也不扩容吧。
    
    1 回复 0   0   0  
  • 88250 • 4 个月前

    放的是同一个值

    0   0   0  
  • 88250 • 4 个月前

    放的是同一个值

    0   0   0  
  • Hassan • 4 个月前

    阶乘累加啊。很大的一个对象。

    0   0   0  
  • Hassan • 4 个月前

    你这inner1和outer区别不大吧,只是把length变成了for的局部变量。按到里,差不多才对。你多执行几遍看看。

    0   0   0  
  • eddy • 4 个月前

    赞一个

    0   0   0  
  • meikaiyipian • 4 个月前

    和JDK版本以及JVM厂商有关?

    1 回复 0   0   0  
  • 88250 • 4 个月前

    没有统计过,可能有关的。

    0   0   0  
  • yanny • 4 个月前

    1475129195930

    Set 第一次快一些,List第二次快

    1 回复 0   0   0  

赞助商 我要投放

又拍云
又拍云上线 Let’s Encrypt 和 Symantec 免费证书
到期后可免费续签
Promoted by 又拍云