JAVA逃逸分析、栈上分配、标量替换、同步消除

一、逃逸分析

逃逸分析是编译语言中的一种优化分析，而不是一种优化的手段。通过对象的作用范围的分析，为其他优化手段提供分析数据从而进行优化。
逃逸分析包括：

• 全局变量赋值逃逸
• 方法返回值逃逸
• 实例引用发生逃逸
• 线程逃逸:赋值给类变量或可以在其他线程中访问的实例变量.

public class EscapeAnalysis {

     public static Object object;
     
     public void globalVariableEscape(){//全局变量赋值逃逸  
         object =new Object();  
      }  
     
     public Object methodEscape(){  //方法返回值逃逸
         return new Object();
     }
     
     public void instancePassEscape(){ //实例引用发生逃逸
        this.speak(this);
     }
     
     public void speak(EscapeAnalysis escapeAnalysis){
         System.out.println("Escape Hello");
     }
}

使用方法逃逸的案例进行分析:

     public StringBuffer createString(String ... values){
         StringBuffer stringBuffer = new StringBuffer(); 
         for (String string : values) {
             stringBuffer.append(string+",");
        }
         return stringBuffer;
     }
     
     public static void main(String[] args) {
        StringBuffer sb = new EscapeAnalysis().createString("Escape","Hello");
        System.out.println(sb.toString());
    }

从上面的案例我们看出stringBuffer是属于方法返回值逃逸。我们可以通过改变返回值得类型为String限定了StringBuffer的作用域在createString方法中从而不发生逃逸。

     public String createString(String ... values){
         StringBuffer stringBuffer = new StringBuffer(); 
         for (String string : values) {
             stringBuffer.append(string+",");
        }
         return stringBuffer.toString();
     }
     
     public static void main(String[] args) {
         String string = new EscapeAnalysis().createString("Escape","Hello");
        System.out.println(string);
    }

二 、栈上分配

我们通过JVM内存分配可以知道JAVA中的对象都是在堆上进行分配，当对象没有被引用的时候，需要依靠GC进行回收内存，如果对象数量较多的时候，会给GC带来较大压力，也间接影响了应用的性能。为了减少临时对象在堆内分配的数量，JVM通过逃逸分析确定该对象不会被外部访问。那就通过标量替换将该对象分解在栈上分配内存，这样该对象所占用的内存空间就可以随栈帧出栈而销毁，就减轻了垃圾回收的压力。

通过-XX:-DoEscapeAnalysis关闭逃逸分析

测试逃逸分析后堆内存对比：

    private  int count = 1000000;
     
    public static void main(String[] args) throws InterruptedException, IOException {
        EscapeAnalysis escapeAnalysis = new EscapeAnalysis();
        for (int i = 0; i < escapeAnalysis.count ; i++) {
            escapeAnalysis.getAge();
        }
        Thread.sleep(500);
        for (int i = 0; i < escapeAnalysis.count ; i++) {
            escapeAnalysis.getAge();
        }
        System.in.read();
    }
    
    
    public int  getAge(){
        Person person = new Person("小明",18,28.1);   
        return person.getAge();
    }
    
    class Person {

        private String name;
        
        private int age;
        
        private double weight;
       
        public Person(String name, int age, double weight) {
            super();
            this.name = name;
            this.age = age;
            this.weight = weight;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public double getWeight() {
            return weight;
        }

        public void setWeight(double weight) {
            this.weight = weight;
        }
    
    }

1.通过jps查看Class的Main进程的PID:

• 关闭逃逸分析的数据

C:\Users\li>jps
13216
16592 EscapeAnalysis
5640
17308
17916 Jps
9308 RemoteMavenServer

• 启用逃逸分析的数据，在JDK1.8是默认开启逃逸分析

C:\Users\li>jps
13216
13412 Jps
5640
17308
6460 EscapeAnalysis
7100 EscapeAnalysis
9308 RemoteMavenServer

2.通过jmap -histo [pid]查看java堆上的对象分布情况:

• 关闭逃逸分析的数据

C:\Users\li>jmap -histo 16592

 num     #instances         #bytes  class name
----------------------------------------------
   1:        980000       31360000  test.EscapeAnalysis$Person
   2:           154         785000  [I
   3:          2158         288504  [C
   4:           489          55832  java.lang.Class
   5:          2017          48408  java.lang.String
   6:           839          33560  java.util.TreeMap$Entry

• 启用逃逸分析的数据

C:\Users\li>jmap -histo 7100

 num     #instances         #bytes  class name
----------------------------------------------
   1:        229881        7356192  test.EscapeAnalysis$Person
   2:           446         756944  [I
   3:          3105         442024  [C
   4:          2408          57792  java.lang.String

通过上面数据可以看出没有开启逃逸分析时，Person在堆的内存是31360000 ，而开启逃逸分析时，Person在堆中的内存为7356192。 两者之间相差24003808。证明了启用了逃逸分析，可以减少堆内存的使用和减少GC。

三、标量替换

1.标量和聚合量

标量即不可被进一步分解的量，而JAVA的基本数据类型就是标量（如：int，long等基本数据类型以及reference类型等），标量的对立就是可以被进一步分解的量，而这种量称之为聚合量。而在JAVA中对象就是可以被进一步分解的聚合量。

2.替换过程

通过逃逸分析确定该对象不会被外部访问，并且对象可以被进一步分解时，JVM不会创建该对象，而会将该对象成员变量分解若干个被这个方法使用的成员变量所代替。这些代替的成员变量在栈帧或寄存器上分配空间。

通过-XX:+EliminateAllocations可以开启标量替换， -XX:+PrintEliminateAllocations查看标量替换情况（Server VM 非Product版本支持）

四、同步消除

同步消除是java虚拟机提供的一种优化技术。通过逃逸分析，可以确定一个对象是否会被其他线程进行访问。

如果你定义的类的方法上有同步锁，但在运行时，却只有一个线程在访问，此时逃逸分析后的机器码，会去掉同步锁运行，这就是没有出现线程逃逸的情况。那该对象的读写就不会存在资源的竞争，不存在资源的竞争，则可以消除对该对象的同步锁。

通过-XX:+EliminateLocks可以开启同步消除,进行测试执行的效率

     public String createString(String ... values){
         StringBuffer stringBuffer = new StringBuffer(); 
         for (String string : values) {
             stringBuffer.append(string+" ");
        }
         return stringBuffer.toString();
     }   
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        EscapeAnalysis escapeAnalysis = new EscapeAnalysis();
        for (int i = 0; i < 1000000; i++) {
            escapeAnalysis.createString("Escape", "Hello");
        }
        long bufferCost = System.currentTimeMillis() - start;
        System.out.println("craeteString: " + bufferCost + " ms");
    }

-server -XX:+DoEscapeAnalysis -XX:-EliminateLocks
craeteString: 202 ms

-server -XX:+DoEscapeAnalysis -XX:+EliminateLocks
craeteString: 173 ms

我们可以通过测试结果看出，如果开启了同步消除，在开启同步消除的执行效率比没有开启同步消除的高。

原文链接：https://www.jianshu.com/p/580f17760f6e