jvm逃逸分析

概念引入

咱们都知道,Java 建立的对象都是被分配到堆内存上,可是事实并非这么绝对,经过对Java对象分配的过程分析,能够知道有两个地方会致使Java中建立出来的对象并必定分别在所认为的堆上。这两个点分别是Java中的逃逸分析和TLAB(Thread Local Allocation Buffer)线程私有的缓存区。html

基本概念介绍

逃逸分析,是一种能够有效减小Java程序中同步负载和内存堆分配压力的跨函数全局数据流分析算法。经过逃逸分析,Java Hotspot编译器可以分析出一个新的对象的引用的使用范围从而决定是否要将这个对象分配到堆上。java

在计算机语言编译器优化原理中,逃逸分析是指分析指针动态范围的方法,它同编译器优化原理的指针分析和外形分析相关联。当变量(或者对象)在方法中分配后,其指针有可能被返回或者被全局引用,这样就会被其余过程或者线程所引用,这种现象称做指针(或者引用)的逃逸(Escape)。通俗点讲,若是一个对象的指针被多个方法或者线程引用时,那么咱们就称这个对象的指针发生了逃逸。算法

Java在Java SE 6u23以及之后的版本中支持并默认开启了逃逸分析的选项。Java的 HotSpot JIT编译器,可以在方法重载或者动态加载代码的时候对代码进行逃逸分析,同时Java对象在堆上分配和内置线程的特色使得逃逸分析成Java的重要功能。缓存

代码示例性能优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package me.stormma.gc;
/**
* <p>Created on 2017/4/21.</p>
*
* @author stormma
*
* @title <p>逃逸分析</p>
*/
public class EscapeAnalysis {
public static B b;
/**
* <p>全局变量赋值发生指针逃逸</p>
*/
public void globalVariablePointerEscape() {
b = new B();
}
/**
* <p>方法返回引用,发生指针逃逸</p>
* @return
*/
public B methodPointerEscape() {
return new B();
}
/**
* <p>实例引用发生指针逃逸</p>
*/
public void instancePassPointerEscape() {
methodPointerEscape().printClassName( this );
}
class B {
public void printClassName(EscapeAnalysis clazz) {
System.out.println(clazz.getClass().getName());
}
}
}

逃逸分析研究对于 java 编译器有什么好处呢?咱们知道 java 对象老是在堆中被分配的,所以 java 对象的建立和回收对系统的开销是很大的。java 语言被批评的一个地方,也是认为 java 性能慢的一个缘由就是 java不支持栈上分配对象。JDK6里的 Swing内存和性能消耗的瓶颈就是因为 GC 来遍历引用树并回收内存的,若是对象的数目比较多,将给 GC 带来较大的压力,也间接得影响了性能。减小临时对象在堆内分配的数量,无疑是最有效的优化方法。java 中应用里广泛存在一种场景,通常是在方法体内,声明了一个局部变量,而且该变量在方法执行生命周期内未发生逃逸,按照 JVM内存分配机制,首先会在堆内存上建立类的实例(对象),而后将此对象的引用压入调用栈,继续执行,这是 JVM优化前的方式。固然,咱们能够采用逃逸分析对 JVM 进行优化。即针对栈的从新分配方式,首先咱们须要分析而且找到未逃逸的变量,将该变量类的实例化内存直接在栈里分配,无需进入堆,分配完成以后,继续调用栈内执行,最后线程执行结束,栈空间被回收,局部变量对象也被回收,经过这种方式的优化,与优化前的方案主要区别在于对象的存储介质,优化前是在堆中,而优化后的是在栈中,从而减小了堆中临时对象的分配(较耗时),从而优化性能。app

使用逃逸分析进行性能优化(-XX:+DoEscapeAnalysis开启逃逸分析)函数

1
2
3
4
5
6
public void method() {
Test test = new Test();
//处理逻辑
......
test = null ;
}

这段代码,之因此能够在栈上进行内存分配,是由于没有发生指针逃逸,便是引用没有暴露出这个方法体。性能

栈和堆内存分配比较

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package me.stormma.gc;
/**
* <p>Created on 2017/4/21.</p>
*
* @author stormma
* @description: <p>内存分配比较</p>
*/
public class EscapeAnalysisTest {
public static void alloc() {
byte [] b = new byte [ 2 ];
b[ 0 ] = 1 ;
}
public static void main(String[] args) {
long b = System.currentTimeMillis();
for ( int i = 0 ; i < 100000000 ; i++) {
alloc();
}
long e = System.currentTimeMillis();
System.out.println(e - b);
}
}

JVM 参数为-server -Xmx10m -Xms10m -XX:-DoEscapeAnalysis -XX:+PrintGC, 运行结果测试

JVM 参数为-server -Xmx10m -Xms10m -XX:+DoEscapeAnalysis -XX:+PrintGC, 运行结果优化

性能测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package me.stormma.gc;
/**
* <p>Created on 2017/4/21.</p>
*
* @author stormma
*
* @description: <p>利用逃逸分析进行性能优化</p>
*/
public class EscapeAnalysisTest {
private static class Foo {
private int x;
private static int counter;
public Foo() {
x = (++counter);
}
}
public static void main(String[] args) {
long start = System.nanoTime();
for ( int i = 0 ; i < 1000 * 1000 * 10 ; ++i) {
Foo foo = new Foo();
}
long end = System.nanoTime();
System.out.println( "Time cost is " + (end - start));
}
}

使用逃逸分析优化 JVM输出结果( -server -XX:+DoEscapeAnalysis -XX:+PrintGC)

1
Time cost is 11012345

未使用逃逸分析优化 JVM 输出结果( -server -Xmx10m -Xms10m -XX:-DoEscapeAnalysis -XX:+PrintGC)

1
2
3
4
5
[GC (Allocation Failure) 33280K->408K(125952K), 0.0010344 secs]
[GC (Allocation Failure) 33688K->424K(125952K), 0.0009799 secs]
[GC (Allocation Failure) 33704K->376K(125952K), 0.0007297 secs]
[GC (Allocation Failure) 33656K->456K(159232K), 0.0014817 secs]
Time cost is 68562263

分析结果,性能优化1/6。


来自:www.importnew.com/27262.html