逃逸分析详解（java代码）

其实，在Java的编译体系中，一个java源代码变成计算机可执行的机器指令代码的过程中，是需要经过两段编译，第一段的编译是把 .java文件编译成 .class文件。第二段编译是把  .class文件转换成机器指令的过程。

通俗的讲，第一段编译就是javac命令。

第二段是编译阶段，JVM 通过解释字节码将其翻译成对应的机器指令，逐条读入，逐条解释翻译。很显然，经过解释执行，其执行速度必然会比可执行的二进制字节码程序慢很多。这就是传统的JVM的解释器（Interpreter）的功能。为了解决这种效率问题，引入了 JIT（即时编译） 技术，引入了 JIT 技术后，Java程序还是通过解释器进行解释执行，当JVM发现某个方法或代码块运行特别频繁的时候，就会认为这是“热点代码”（Hot Spot Code)。然后JIT会把部分“热点代码”翻译成本地机器相关的机器码，并进行优化，然后再把翻译后的机器码缓存起来，以备下次使用。
 

JIT优化中最重要的一个就是逃逸分析。

逃逸分析介绍：

概念：逃逸分析，是一种可以有效减少Java 程序中同步负载和内存堆分配压力的跨函数全局数据流分析算法。通过逃逸分析，Java Hotspot编译器能够分析出一个新的对象的引用的使用范围从而决定是否要将这个对象分配到堆上。逃逸分析的基本行为就是分析对象动态作用域。

逃逸分析类型：

方法逃逸(对象逃出当前方法)

                        当一个对象在方法中被定义后，它可能被外部方法所引用，例如作为调用参数传递到其他地方中。

　　线程逃逸((对象逃出当前线程)

　　　　　　这个对象甚至可能被其它线程访问到，例如赋值给类变量或可以在其它线程中访问的实例变量。

这里我拿方法逃逸举例分析：

public class TaoYiDemo {


    /**
     *      例子一
     * @param a1
     * @param a2
     * @return
     */
    public  static  StringBuffer taoyi01(String a1,String a2){
        StringBuffer stringBuffer01=new StringBuffer();
        stringBuffer01.append(a1);
        stringBuffer01.append(a2);
        return stringBuffer01;
    }

    /**
     *    例子二
     * @param a1
     * @param a2
     * @return
     */
    public  static  String taoyi02(String a1,String a2){
        StringBuffer stringBuffer02=new StringBuffer();
        stringBuffer02.append(a1);
        stringBuffer02.append(a2);
        return stringBuffer02.toString();
    }
    

}

这里例子一的代码stringBuffer01就发生了逃逸，而stringBuffer02则没有逃逸。

使用逃逸分析

 编译器可以对代码做如下优化：

1：同步省略或锁消除(Synchronization Elimination)。如果一个对象被发现只能从一个线程被访问到，那么对于这个对象的操作可以不考虑同步。（在动态编译同步块的时候，JIT编译器可以借助逃逸分析来判断同步块所使用的锁对象是否只能够被一个线程访问而没有被发布到其他线程。）

代码：

     public void TongBu(){
            Object object =new Object();
            synchronized (object){
                System.out.println(object);
            }
        }

代码中对object这个对象进行加锁，但是object对象的生命周期只在TongBu()方法中，并不会被其他线程所访问到，所以在JIT编译阶段就会被优化掉。优化成

   public void TongBu01() {
        Object object = new Object();
        System.out.println(object);
    }

所以，在使用synchronized的时候，如果JIT经过逃逸分析之后发现并无线程安全问题的话，就会做锁消除。

2：将堆分配转化为栈分配(Stack Allocation)。如果一个对象在子程序中被分配，要使指向该对象的指针永远不会逃逸，对象可能是栈分配的候选，而不是堆分配。

3：分离对象或标量替换(Scalar Replacement)。有的对象可能不需要作为一个连续的内存结构存在也可以被访问到，那么对象的部分（或全部）可以不存储在内存，而是存储在CPU寄存器中。（这里的标量(Scalar)是指的是一个无法在分解的成的更小的是数据）

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

    private static void alloc() {
        Point point = new Point(1,2);
        System.out.println("point.x="+point.x+"; point.y="+point.y);
    }
    class Point{
        private int x;
        private int y;
    }

以上代码中，point对象并没有逃逸出alloc方法，并且point对象是可以拆解成标量的。那么，JIT就会不会直接创建Point对象，而是直接使用两个标量int x ，int y来替代Point对象,经过变量替换后，就变成：

private static void alloc() {
   int x = 1;
   int y = 2;
   System.out.println("point.x="+x+"; point.y="+y);
}

可以看到，Point这个聚合量经过逃逸分析后，发现他并没有逃逸，就被替换成两个聚合量了。那么标量替换有什么好处呢？就是可以大大减少堆内存的占用。因为一旦不需要创建对象了，那么就不再需要分配堆内存了。标量替换为栈上分配提供了很好地基础。

栈上分配

在Java虚拟机中，对象是在Java堆中分配内存的，这是一个普遍的常识。但是，有一种特殊情况，那就是如果经过逃逸分析后发现，一个对象并没有逃逸出方法的话，那么就可能被优化成栈上分配。这样就无需在堆上分配内存，也无须进行垃圾回收了。

jdk1.6才开始引入该技术，jdk1.7开始默认开启逃逸分析。在java代码运行时，可以通过JVM参数指定是否开启逃逸分析：

‐XX:+DoEscapeAnalysis //表示开启逃逸分析 (jdk1.8默认开启）
‐XX:‐DoEscapeAnalysis //表示关闭逃逸分析。
‐XX:+EliminateAllocations //开启标量替换(默认打开)
‐XX:+EliminateLocks //开启锁消除(jdk1.8默认开启）

当然，跟JVM交互也是有一个特别好用的软件，是阿里巴巴出品的 Arthas (阿尔萨斯)。

官方网址：arthas

Arthas的文档写的非常棒，而且有demo,可以说是一看就会，大家快去学习吧。

奥利给~   今天就到这里吧 散会！！！！！