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

迈不过友情╰ 2021-06-24 13:57 463阅读 0赞

一、逃逸分析

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

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

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);
        }

一、标量替换

1.标量和聚合量

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

2.替换过程

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

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

二 、栈上分配

我们通过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。

三、同步消除

同步消除是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

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

Reference：

1.  [http://rednaxelafx.iteye.com/blog/659108/][http_rednaxelafx.iteye.com_blog_659108]

[http_rednaxelafx.iteye.com_blog_659108]: https://link.jianshu.com?t=http%3A%2F%2Frednaxelafx.iteye.com%2Fblog%2F659108%2F