关于【禁止new对象时在for循环内定义申明变量】

简介

不知道是谁最先提出了一个不要将变量定义在循环内。

然后我们在代码扫描中有一项是：【禁止new对象时在for循环内定义申明变量】

我也好奇为什么不能？

是影响了性能？还是影响了内存？还是影响了垃圾回收？

我们站在制定这条规则的人的角度来想一想可能的原因：

1. 变量定义在for循环内，每次都要为变量引用分配空间，效率低
2. 变量定义在for循环内，有引用，不利于内存回收
3. …

真的如此吗？我们先从代码分析一下。

代码分析

我们先从代码的角度分析，局部变量定义在循环外和循环内的区别。

不熟悉局部变量和字节码的朋友可以先看一看：
JVM字节码与局部变量

示例代码如下：

import java.util.HashMap;
import java.util.Map;

public class Main {

    private static final int limit = 1000_0000;

    public static void main(String[] args) {

    }

    public void out() {
        Map<String, String> base;
        for (int i = 0; i < limit; i++) {
            base = new HashMap<>();
            base.put("1", "哦啊好");
            System.out.println(base);
        }
    }

    public void in() {
        for (int i = 0; i < limit; i++) {
            Map<String, String> base = new HashMap<>();
            base.put("1", "哦啊好");
            System.out.println(base);
        }
    }
}

我们可以：

# 编译class
javac Main.java

# 查看字节码
javap -v Main.class

我们可以看到，无论变量定义在循环外还是循环内，base变量在局部变量表都只占据了一个slot。

自然，也就没有每次循环都要给变量引用分配空间的问题。至于base堆上的内存空间，无论变量定义在循环内外，肯定都要分配，没有区别。

至于垃圾回收，无论变量base在循环内还是循环外，局部变量base引用的都是最新new出来的Map对象，旧的对象不被引用，自然可以被回收，一点也不影响。

基本一模一样，不信我吗可以看看反编译之后的代码。

反编译之后对比

//
// Source code recreated from a .class file
// (powered by FernFlower decompiler)
//

package vip.meet;

import java.util.HashMap;
import java.util.Map;

public class Main {
    private static final int limit = 10000000;

    public Main() {
    }

    public static void main(String[] args) {
    }

    public void out() {
        for(int i = 0; i < 10000000; ++i) {
            Map<String, String> base = new HashMap();
            base.put("1", "哦啊好");
            System.out.println(base);
        }

    }

    public void in() {
        for(int i = 0; i < 10000000; ++i) {
            Map<String, String> base = new HashMap();
            base.put("1", "哦啊好");
            System.out.println(base);
        }

    }
}

我们可以看到反编译之后，out方法的变量被放在循环中了，变得和in一模一样了。

有朋友肯能说，我看到了，他们字节码不一样啊，反编译出来的代码不能说明什么。

把out稍微改一下，将int i定义放在Map的base之前，字节码就一样了。

public void out() {
    int i = 0;
    Map<String, String> base;
    for (; i < limit; i++) {
        base = new HashMap<>();
        base.put("1", "哦啊好");
        System.out.println(base);
    }
}

如果，还觉得有疑问，我们下面来做点性能测试。

性能测试

我们先用benchmark做一些性能测试：

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import org.openjdk.jmh.runner.options.TimeValue;

import java.util.HashMap;
import java.util.Map;

public class BenchmarkLocalVarTest {

    private static final int limit = 10000_0000;

    @Benchmark
    public void out() {
        Map<String, String> base;
        for (int i = 0; i < limit; i++) {
            base = new HashMap<>();
            base.put("1", "哦啊好");
        }
    }

    @Benchmark
    public void in() {
        for (int i = 0; i < limit; i++) {
            Map<String, String> base = new HashMap<>();
            base.put("1", "哦啊好");
        }
    }

    public static void main(String[] args) throws RunnerException {
        Options options = new OptionsBuilder()
                .include(BenchmarkLocalVarTest.class.getSimpleName())
                .forks(1)
                .timeout(TimeValue.seconds(10))
                .threads(1)
                .warmupIterations(1)
                .warmupTime(TimeValue.seconds(10))
                .measurementTime(TimeValue.seconds(2))
                .measurementIterations(5)
                .build();
        new Runner(options).run();
    }
}

Benchmark                   Mode  Cnt  Score   Error  Units
BenchmarkLocalVarTest.in   thrpt    5  0.349 ± 0.037  ops/s
BenchmarkLocalVarTest.out  thrpt    5  0.335 ± 0.039  ops/s

如果还有朋友觉得这个测试只能说明性能，不能看出内存和垃圾回收，那我们在来看一下内存和垃圾回收。

内存与垃圾回收情况

变量定义在循环内gc情况：

变量定义在循环内内存情况：

变量定义在循环外gc情况：

变量定义在循环外内存情况：

我们可以看到，没有太大区别，如果觉得上面逻辑太简单，可以自己试一下更复杂的情况。

JDK和常用框架怎么写

如果这样还不放心，那我们再看一下其他大神怎么写的：

JDK LinkedBlockingDeque:

Spring ResourceUrlProvider:

apache io FileUtils:

guava Files:

总结

综上所述，【禁止new对象时在for循环内定义申明变量】并没有什么意义。

甚至，还带来了负面效果：

1. 让变量作用域变大，存在被无意引用的风险
2. 更容易产生变量名冲突
3. 可读性变差

依赖

<dependency>
    <groupId>org.openjdk.jmh</groupId>
    <artifactId>jmh-core</artifactId>
    <version>1.36</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.openjdk.jmh</groupId>
    <artifactId>jmh-generator-annprocess</artifactId>
    <version>1.36</version>
</dependency>