JVM 之逃逸分析技术

曾经终败给现在 2022-08-30 11:18 42阅读 0赞

**引言**

我在面试别人的过程中，`JVM 内存模型`我几乎必问，虽然有人说问这些就是`面试造航母，工作拧螺丝`。如果你想当一名 CRUD 码农，你可以选择不用了解这些。

在 JVM 内存模型的问答中，有些人能说出对象是在堆上分配的。但当我问对象一定是在堆上存储的嘛时，大部分人都回答是，或者犹豫了。

其实能回答出对象是在堆上分配存储已算正确了。但随着 `JIT` 即时编译器的发展和逃逸分析技术的逐渐成熟，所有对象都分配到堆上也逐渐变得不那么绝对了。`栈上分配`，`标量替换`，`锁消除`等优化技术会发生一些微妙的变化。

我们知道，我们编写的 Java 源代码通过 javac 编译成字节码文件，然后类加载器将字节码文件加载到内存中，JVM 逐行读取解释字节码翻译成对应的机器指令执行。很明显，解释执行比那些可直接执行的二进制程序（例如 C 语言程序）慢得多。

所以为了提高效率，引入了 JIT （即时编译器）优化技术。Java 程序还是会通过解释器进行解释执行，但是如果某个方法或者代码块运行比较频繁的时候，JVM 认为这是`热点代码`，然后将热点代码翻译成本地机器指令，并且进行优化，缓存起来，下次再运行此段代码的时候直接运行而不用再解释。

JIT 中一个很重要的优化技术就是逃逸分析（Escape Analysis）。

## **逃逸分析** ##

逃逸分析，其实就是分析一个对象是否会逃逸出方法，分析对象的动态作用域。如果一个对象在一个方法内定义，并且有可能被方法外部引用使用，那认为它逃逸了。

例如以下的 person 对象就发生了逃逸，即有可能会被方法外部引用。

public Person personEscape() {
      Person person = new Person();
      return person;
    }

所以为什么要进行逃逸分析，其实最终目的就是为程序做优化，提高运行性能。有如下优化技术点：

*  栈上分配
 *  标量替换
 *  锁消除

JDK1.7 开始，逃逸分析默认是开启的，可以通过以下参数进行启停。

# 开启
    -XX:+DoEscapeAnalysis
    # 关闭
    -XX:-DoEscapeAnalysis

### **栈上分配** ###

如果分析一个对象没有逃逸出方法的时候，就有可能被分配到栈上。这样就不需要在堆中进行 GC 回收，提高了性能。

package com.chenpi;
    
    /**
     * @Description
     * @Author 陈皮
     * @Date 2021/7/14
     * @Version 1.0
     */
    public class EscapeAnalysisTest {
    
      public static void main(String[] args) {
    
        long startTime = System.currentTimeMillis();
    
        for (int i = 0; i < 10000000; i++) {
          stackAlloc();
        }
    
        System.out.println((System.currentTimeMillis() - startTime) + "ms");
      }
    
      public static void stackAlloc() {
        Person person = new Person("陈皮", 18);
      }
    
    }
    
    class Person {
    
      private String name;
      private long age;
    
      public Person(String name, long age) {
        this.name = name;
        this.age = age;
      }
    }

虚拟机参数设置开启逃逸分析，并且打印 GC 日志。

-Xms200m -Xmx200m -XX:+DoEscapeAnalysis -XX:+PrintGC

运行程序结果如下，消耗只需要 10 ms，并且没有 GC 。

10ms

关闭逃逸分析，并且打印 GC 日志。

-Xms200m -Xmx200m -XX:-DoEscapeAnalysis -XX:+PrintGC

运行程序结果如下，消耗时间增加了10多倍，并且伴随着多次的 GC 。

[GC (Allocation Failure)  51712K->784K(196608K), 0.0050396 secs]
    [GC (Allocation Failure)  52496K->784K(196608K), 0.0030730 secs]
    [GC (Allocation Failure)  52496K->752K(196608K), 0.0013993 secs]
    [GC (Allocation Failure)  52464K->720K(196608K), 0.0018371 secs]
    176ms

### **标量替换** ###

*  标量：不可再分解成更小数据的类型，例如基本数据类型就是标量。
 *  聚合量：可以再分解成其他聚合量或者标量的数据类型，例如对象引用类型。

如果一个对象不会发生逃逸，那么 JIT 可以优化把这个对象分解成若干个标量来代替。这就是标量替换。

public void scalarReplace() {
      Coordinates coordinates = new Coordinates(105.10, 80.22);
      System.out.println(coordinates.longitude);
      System.out.println(coordinates.latitude);
    }

以上演示程序，coordinates 对象不会发生逃逸，所以 JIT 编译器可以使用标量替换进行优化。最终被优化成如下程序。

public void scalarReplace() {
      System.out.println(105.10);
      System.out.println(80.22);
    }

其实在现有的虚拟机中，并没有真正的实现栈上分配，其实是通过标量替换来实现的。

**锁消除**

为什么要消除锁呢？因为加锁会降低性能，那如何不用加锁是最好的。如果分析出加锁的对象不会发生逃逸，即只能被一个线程访问，JIT 是可以优化消除这个锁的。也称为同步省略。

public void lockRemove() {
      synchronized (new Object()) {
        System.out.println("我是陈皮！");
      }
    }

以上演示程序，Object 对象不会发生逃逸，所以也只能当前线程访问到，所以 JIT 编译器可以进行优化锁消除。最终被优化成如下程序。

public void lockRemove() {
      System.out.println("我是陈皮！");
    }

## **总结** ##

但随着 JIT 即时编译器的发展和逃逸分析技术的逐渐成熟，所有对象都分配到堆上也逐渐变得不那么绝对了。通过逃逸分析技术，对象可能被分配到栈上，能减少 GC，提高程序性能。

但是开启逃逸分析的程序的性能一定高于没有开启逃逸分析的性能吗？其实不一定。逃逸分析技术其实也是很复杂的，所以也是一个会耗时的过程，如果经过逃逸分析之后，发现所有对象都逃逸了，就不能做优化处理，那这个逃逸分析的过程就消耗了时间，还不起优化作用，得不偿失。