什么是逃逸分析

比如jit即时编译中一个方法中定义了一个对象但是没有被其他地方引用，而栈中又放得下的话就会将这个对象放到栈里面

逃逸分析确定某个指针可以存储的所有地方，以及确定能否保证指针的生命周期只在当前进程或线程中。
简单来讲，JVM 中的逃逸分析**可以通过分析对象引用的使用范围（即动态作用域），来决定对象是否要在堆上分配内存，也可以做一些其他方面的优化。

简单来说是可以的，但是Java的分离编译和动态加载使得前期的静态编译的逃逸分析比较困难或收益较少，所以目前Java的逃逸分析只发在JIT的即时编译中，因为收集到足够的运行数据JVM可以更好的判断对象是否发生了逃逸。关于JIT即时编译可参考JVM系列之走进JIT。

JVM判断新创建的对象是否逃逸的依据有：

一、对象被赋值给堆中对象的字段和类的静态变量。
二、对象被传进了不确定的代码中去运行。如果满足了以上情况的任意一种，那这个对象JVM就会判定为逃逸。对于第一种情况，因为对象被放进堆中，则其它线程就可以对其进行访问，所以对象的使用情况，编译器就无法再进行追踪。第二种情况相当于JVM在解析普通的字节码的时候，如果没有发生JIT即时编译，编译器是不能事先完整知道这段代码会对对象做什么操作。保守一点，这个时候也只能把对象是当作是逃逸来处理。下面举几个例子

  1. public class EscapeTest {
  3.     public static Object globalVariableObject;
  5.     public Object instanceObject;
  7.     public void globalVariableEscape(){
  8.         globalVariableObject = new Object(); //静态变量,外部线程可见,发生逃逸
  9.     }
  11.     public void instanceObjectEscape(){
  12.         instanceObject = new Object(); //赋值给堆中实例字段,外部线程可见,发生逃逸
  13.     }
  15.     public Object returnObjectEscape(){
  16.         return new Object();  //返回实例,外部线程可见，发生逃逸
  17.     }
  19.     public void noEscape(){
  20.         synchronized (new Object()){
  21.             //仅创建线程可见,对象无逃逸
  22.         }
  23.         Object noEscape = new Object();  //仅创建线程可见,对象无逃逸
  24.     }
  26. }

基于逃逸分析的优化

当判断出对象不发生逃逸时，编译器可以使用逃逸分析的结果自动的作一些代码优化

优化1 将堆分配转化为栈分配

  • 将堆分配转化为栈分配。如果某个对象在子程序中被分配，并且指向该对象的指针永远不会逃逸，该对象就可以在分配在栈上，而不是在堆上。在有垃圾收集的语言中，这种优化可以降低垃圾收集器运行的频率。

对于优化一将堆分配转化为栈分配，这个优化也很好理解。下面以代码例子说明：
虚拟机配置参数：-XX:+PrintGC -Xms5M -Xmn5M -XX:+DoEscapeAnalysis
-XX:+DoEscapeAnalysis表示开启逃逸分析，JDK8是默认开启的
-XX:+PrintGC 表示打印GC信息
-Xms5M -Xmn5M 设置JVM内存大小是5M

  1.     public static void main(String[] args){
  2.         for(int i = 0; i < 5_000_000; i++){
  3.             createObject();
  4.         }
  5.     }
  7.     public static void createObject(){
  8.         new Object();
  9.     }

运行结果是没有GC。
把虚拟机参数改成 -XX:+PrintGC -Xms5M -Xmn5M -XX:-DoEscapeAnalysis。关闭逃逸分析得到结果的部分截图是，说明了进行了GC，并且次数还不少。

  1. [GC (Allocation Failure)  4096K->504K(5632K), 0.0012864 secs]
  2. [GC (Allocation Failure)  4600K->456K(5632K), 0.0008329 secs]
  3. [GC (Allocation Failure)  4552K->424K(5632K), 0.0006392 secs]
  4. [GC (Allocation Failure)  4520K->440K(5632K), 0.0007061 secs]
  5. [GC (Allocation Failure)  4536K->456K(5632K), 0.0009787 secs]
  6. [GC (Allocation Failure)  4552K->440K(5632K), 0.0007206 secs]
  7. [GC (Allocation Failure)  4536K->520K(5632K), 0.0009295 secs]
  8. [GC (Allocation Failure)  4616K->512K(4608K), 0.0005874 secs]

这说明了JVM在逃逸分析之后，将对象分配在了方法createObject()方法栈上。方法栈上的对象在方法执行完之后，栈桢弹出，对象就会自动回收。这样的话就不需要等内存满时再触发内存回收。这样的好处是程序内存回收效率高，并且GC频率也会减少，程序的性能就提高了。

优化2 同步锁消除

同步消除。如果发现某个对象只能从一个线程可访问，那么在这个对象上的操作可以不需要同步。
**
虚拟机配置参数：-XX:+PrintGC -Xms500M -Xmn500M -XX:+DoEscapeAnalysis。配置500M是保证不触发GC。

  1. public static void main(String[] args){
  2.         long start = System.currentTimeMillis();
  3.         for(int i = 0; i < 5_000_000; i++){
  4.             createObject();
  5.         }
  6.         System.out.println("cost = " + (System.currentTimeMillis() - start) + "ms");
  7.     }
  9.     public static void createObject(){
  10.         synchronized (new Object()){
  12.         }
  13.     }

运行结果

  1. cost = 6ms

把逃逸分析关掉：-XX:+PrintGC -Xms500M -Xmn500M -XX:-DoEscapeAnalysis
运行结果

  1. cost = 270ms

说明了逃逸分析把锁消除了，并在性能上得到了很大的提升。这里说明一下Java的逃逸分析是方法级别的，因为JIT的即时编译是方法级别。

优化3 分离对象或标量替换

分离对象或标量替换。如果某个对象的访问方式不要求该对象是一个连续的内存结构，那么对象的部分（或全部）可以不存储在内存，而是存储在CPU寄存器中。

这个简单来说就是把对象分解成一个个基本类型，并且内存分配不再是分配在堆上，而是分配在栈上。这样的好处有:
一、减少内存使用，因为不用生成对象头。
二、程序内存回收效率高，并且GC频率也会减少，总的来说和上面优点一的效果差不多。

参考

https://zhuanlan.zhihu.com/p/59215831