一、逃逸分析

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

逃逸分析包括：

全局变量赋值逃逸

方法返回值逃逸

实例引用发生逃逸

线程逃逸:赋值给类变量或可以在其他线程中访问的实例变量. 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不会创建该对象，而会将该对象成员变量分解若干个被这个方法使用的成员变量所代替。这些代替的成员变量在栈帧或寄存器上分配空间。

二 、栈上分配

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

测试逃逸分析后堆内存对比： 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虚拟机提供的一种优化技术。通过逃逸分析，可以确定一个对象是否会被其他线程进行访问

如果对象没有出现线程逃逸，那该对象的读写就不会存在资源的竞争，不存在资源的竞争，则可以消除对该对象的同步锁。 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：