一、JVM程序执行流程

上一章我们介绍过程序执行通常分为解释执行和编译执行，而Java两种方式都采用了，下面是Java编译成字节码、动态编译和解释为机器码的过程分析：
在这里插入图片描述

编译器和解释器的协调工作流程：
在这里插入图片描述

判断是否是热点代码，不是则逐行解释每条代码，翻译成机器码执行，否则一次性编译成机器码存到方法区，以后每次直接运行机器码

JIT优化，可以控制判断是否是热点代码的条件，默认一段代码（方法、或循环体）被调用10000次以上被认为是热点代码

JIT编译的Hot热点代码通常是以方法为单位的，最小单位可能是for循环的一段代码

在部分商用虚拟机中（如HotSpot），Java程序最初是通过解释器（Interpreter）进行解释执行的，当虚拟机发现某个方法或代码块的运行特别频繁时，就会把这些代码认定为“热点代码”。为了提高热点代码的执行效率，在运行时，虚拟机将会把这些代码编译成与本地平台相关的机器码，并进行各种层次的优化，完成这个任务的编译器称为即时编译器（Just In Time Compiler，下文统称JIT编译器）。

解释执行：一段代码，解释一行执行一行
编译执行：事先已经编译成机器码，直接执行即可，不用解释

由于Java虚拟机规范并没有具体的约束规则去限制即时编译器应该如何实现，所以这部分功能完全是与虚拟机具体实现相关的内容，如无特殊说明，我们提到的编译器、即时编译器都是指Hotspot虚拟机内的即时编译器，虚拟机也是特指HotSpot虚拟机。

我们的JIT是属于动态编译方式的，动态编译（dynamic compilation）指的是“在运行时进行编译”；与之相对的是事前编译（ahead-of-time compilation，简称AOT），也叫静态编译（static compilation）。

JIT编译（just-in-time compilation）狭义来说是当某段代码即将第一次被执行时进行编译，因而叫“即时编译”。JIT编译是动态编译的一种特例。JIT编译一词后来被泛化，时常与动态编译等价；但要注意广义与狭义的JIT编译所指的区别。

JIT动态编译，只是在运行时把某一部分代码进行动态编译，不是把所有代码全部编译成机器码，哪些代码进行动态编译有一个衡量标准

热点代码编译成机器码后会保存到方法区

1.1 哪些程序代码会被即时编译

程序中的代码只有是热点代码时，才会编译为本地代码，那么什么是热点代码呢？

运行过程中会被即时编译器编译的“热点代码”有两类：

被多次调用的方法。
被多次执行的循环体。

两种情况，编译器都是以整个方法作为编译对象。这种编译方法因为编译发生在方法执行过程之中，因此形象的称之为栈上替换（On Stack Replacement，OSR），即方法栈帧还在栈上，方法就被替换了。

1.2 如何判断热点代码呢

要知道方法或一段代码是不是热点代码，是不是需要触发即时编译，需要进行Hot Spot Detection（热点探测）。

目前主要的热点探测方式有以下两种：

基于采样的热点探测
采用这种方法的虚拟机会周期性地检查各个线程的栈顶，如果发现某些方法经常出现在栈顶，那这个方法就是“热点方法”。这种探测方法的好处是实现简单高效，还可以很容易地获取方法调用关系（将调用堆栈展开即可），缺点是很难精确地确认一个方法的热度，容易因为受到线程阻塞或别的外界因素的影响而扰乱热点探测。
基于计数器的热点探测
采用这种方法的虚拟机会为每个方法（甚至是代码块）建立计数器，统计方法的执行次数，如果执行次数超过一定的阀值，就认为它是“热点方法”。这种统计方法实现复杂一些，需要为每个方法建立并维护计数器，而且不能直接获取到方法的调用关系，但是它的统计结果相对更加精确严谨。

1.3 热点检测方式

在HotSpot虚拟机中使用的是第二种——基于计数器的热点探测方法，因此它为每个方法准备了两个计数器：方法调用计数器和回边计数器。在确定虚拟机运行参数的前提下，这两个计数器都有一个确定的阈值，当计数器超过阈值溢出了，就会触发JIT编译。

1.3.1 方法调用计数器

顾名思义，这个计数器用于统计方法被调用的次数。
在这里插入图片描述

在JVM client模式下的阀值是1500次，Server是10 000次。可以通过虚拟机参数： -XX：CompileThreshold设置。
但是JVM还存在热度衰减，时间段内调用方法的次数较少，计数器就减小。
半衰期：如果计数器在一定时间范围内始终没有达到阈值，下一次周期计数开始，计数起始值直接为阈值一半
向编译器提交编译请求是异步并行方式

1.3.2 回边计数器

它的作用就是统计一个方法中循环体代码执行的次数，在字节码中遇到控制流向后跳转的指令称为“回边”。

二、理解JIT编译器

通过以下问题来了解JIT编译器

为何HotSpot需要使用解释器和编译器并存的架构？
JVM为什么要实现两个不同的即时编译器？
程序何时会使用解释器执行？何时会使用编译器执行？
哪些程序代码会被编译成为本地代码？如何编译？
JAVA代码的执行效率就一定比C，C++静态执行的执行差？JAVA代码解析执行有何优势？

2.1 为什么要使用解释器与编译器并存的架构

尽管并不是所有的Java虚拟机都采用解释器与编译器并存的架构，但许多主流的商用虚拟机（如HotSpot），都同时包含解释器和编译器。

解释器没有编译成本，编译需要花时间和空间，虽然只需要编译一次
解释器不需要占用空间，缺点在于，相对于直接执行机器码需要消耗更多的时间
空间换时间的思想

2.1.1 解释器与编译器特点

当程序需要迅速启动和执行的时候，解释器可以首先发挥作用，省去编译的时间，立即执行。在程序运行后，随着时间的推移，编译器逐渐发挥作用，把越来越多的代码编译成本地代码之后，可以获取更高的执行效率。
当程序运行环境中内存资源限制较大（如部分嵌入式系统中，安卓），可以使用解释器执行节约内存，反之可以使用编译执行来提升效率。

2.1.2 编译的时间开销

解释器的执行，抽象的看是这样的：
输入的代码 -> [ 解释器解释执行 ] -> 执行结果

而要JIT编译然后再执行的话，抽象的看则是：
输入的代码 -> [ 编译器编译 ] -> 编译后的代码 -> [ 执行 ] -> 执行结果

说JIT比解释快，其实说的是“执行编译后的代码”比“解释器解释执行”要快，并不是说“编译”这个动作比“解释”这个动作快。JIT编译再怎么快，至少也比解释执行一次略慢一些，而要得到最后的执行结果还得再经过一个“执行编译后的代码”的过程。所以，对“只执行一次”的代码而言，解释执行其实总是比JIT编译执行要快。

怎么算是“只执行一次的代码”呢？粗略说，下面两个条件同时满足时就是严格的“只执行一次”

1、只被调用一次，例如类的构造器（class initializer()）
2、没有循环

对只执行一次的代码做JIT编译再执行，可以说是得不偿失。
对只执行少量次数的代码，JIT编译带来的执行速度的提升也未必能抵消掉最初编译带来的开销。
只有对频繁执行的代码，JIT编译才能保证有正面的收益。

2.1.3 编译的空间开销

对一般的Java方法而言，编译后代码的大小相对于字节码的大小，膨胀比达到10x是很正常的。同上面说的时间开销一样，这里的空间开销也是，只有对执行频繁的代码才值得编译，如果把所有代码都编译则会显著增加代码所占空间，导致“代码爆炸”。

这也就解释了为什么有些JVM会选择不总是做JIT编译，而是选择用解释器+JIT编译器的混合执行引擎。

2.2 为何要实现两个不同的即时编译器

HotSpot虚拟机中内置了两个即时编译器：Client Complier和Server Complier，简称为C1、C2编译器，分别用在客户端和服务端。

目前主流的HotSpot虚拟机中默认是采用解释器与其中一个编译器直接配合的方式工作。程序使用哪个编译器，取决于虚拟机运行的模式。HotSpot虚拟机会根据自身版本与宿主机器的硬件性能自动选择运行模式，用户也可以使用“-client”或“-server”参数去强制指定虚拟机运行在Client模式或Server模式。

用Client Complier获取更高的编译速度，用Server Complier 来获取更好的编译质量（例如 JIT优化）。为什么提供多个即时编译器与为什么提供多个垃圾收集器类似，都是为了适应不同的应用场景。

编译质量的意思就是在编译过程中会进行优化，Client Complier优化的少，Server Complier优化的多，优化多则启动慢

2.3 如何编译为本地代码？

Server Compiler和Client Compiler两个编译器的编译过程是不一样的。

对Client Compiler来说，它是一个简单快速的编译器，主要关注点在于局部优化，而放弃许多耗时较长的全局优化手段。

而Server Compiler则是专门面向服务器端的，并为服务端的性能配置特别调整过的编译器，是一个充分优化过的高级编译器。

三、JIT优化

HotSpot 虚拟机使用了很多种优化技术，这里只简单介绍其中的几种，完整的优化技术介绍可以参考官网内容。

JIT编译优化，不是在javac命令编译优化，是在jvm运行期间的优化策略

3.1 公共子表达式的消除

公共子表达式消除是一个普遍应用于各种编译器的经典优化技术，他的含义是：如果一个表达式E已经计算过了，并且从先前的计算到现在E中所有变量的值都没有发生变化，那么E的这次出现就成为了公共子表达式。对于这种表达式，没有必要花时间再对他进行计算，只需要直接用前面计算过的表达式结果代替E就可以了。

如果这种优化仅限于程序的基本块内，便称为局部公共子表达式消除（Local Common Subexpression Elimination）
如果这种优化范围涵盖了多个基本块，那就称为全局公共子表达式消除（Global Common Subexpression Elimination）。

举个简单的例子来说明他的优化过程，假设存在如下代码：

int d = (c*b)*12+a+(a+b*c);

注意只有多次调用发现c和b都是一个值才会把b*c的结果缓存

如果这段代码交给Javac编译器则不会进行任何优化，那生成的代码如下所示，是完全遵照Java源码的写法直译而成的。

iload_2 // b
imul // 计算b*c
bipush 12 // 推入12
imul // 计算(c*b)*12
iload_1 // a
iadd // 计算(c*b)*12+a
iload_1 // a
iload_2 // b
iload_3 // c
imul // 计算b*c
iadd // 计算a+b*c
iadd // 计算(c*b)*12+a+(a+b*c)
istore 4

当这段代码进入到虚拟机即时编译器后，他将进行如下优化：编译器检测到”cb“与”bc“是一样的表达式，而且在计算期间b与c的值是不变的。因此，这条表达式就可能被视为：

int d = E*12+a+(a+E);

这时，编译器还可能（取决于哪种虚拟机的编译器以及具体的上下文而定）进行另外一种优化：代数化简（Algebraic Simplification），把表达式变为：

 int d = E*13+a*2;

表达式进行变换之后，再计算起来就可以节省一些时间了。

由于E已经是被计算之后的结果，因此可以直接替换成一个常量值

变量和常量的操作不同，常量可以直接压入到局部变量表，而变量先要取到操作栈，再从操作栈取出来存储到局部变量表

3.2 方法内联

JVM中如何执行方法：

结构：方法区中class对象的方法在class文件加载到方法区时将符号引用解析为直接引用，指向method对象（Field对象类似），method对象除了有自己的地址外，有一个code区专门存放要执行的字节码指令

执行流程：线程执行方法的时候，会先读取class对象信息，再从class信息获取到要执行的方法地址，然后把方法形成栈帧压入到栈，方法执行过程中内部如果又调用其他方法以此类推将需要执行的方法压入栈里，栈顶的方法就是正在执行的方法，一旦某一个方法执行完了就会弹栈

如果方法调用很多的话，方法入栈出栈的操作也会很多，栈会很深，对应性能损耗也很多

在使用JIT进行即时编译时，将方法调用直接使用方法体中的代码进行替换，这就是方法内联，减少了方法调用过程中压栈与入栈的开销。同时为之后的一些优化手段提供条件。如果JVM监测到一些小方法被频繁的执行，它会把方法的调用替换成方法体本身。

比如说下面这个：

private int add4(int x1， int x2， int x3， int x4) {
    
    
	return add2(x1， x2) + add2(x3， x4);
}
private int add2(int x1， int x2) {
    
    
	return x1 + x2;
}

可以肯定的是运行一段时间后JVM会把add2方法去掉，并把你的代码翻译成：

private int add4(int x1， int x2， int x3， int x4) {
    
    
	return x1 + x2 + x3 + x4;
}

可以有效防止栈溢出，以及方法调用过程中压栈与入栈的开销

3.3 逃逸分析

逃逸分析(Escape Analysis)是目前Java虚拟机中比较前沿的优化技术。这是一种可以有效减少Java程序中同步负载内存堆分配压力的跨函数全局数据流分析算法。通过逃逸分析，Java Hotspot编译器能够分析出一个新的对象的引用的使用范围从而决定是否要将这个对象分配到堆上。

同步负载：指的是加锁synchronized的压力
内存堆分配：堆里面分配对象

算法具体实现不用深究，只要知道逃逸分析能够带来的效果即可。

逃逸分析的基本行为就是分析对象动态作用域：当一个对象在方法中被定义后，它可能被外部方法所引用，例如作为调用参数传递到其他地方中，称为方法逃逸。

对象不能被外部访问，则没有逃逸，没有逃逸可以进行一系列优化，主要有三种优化策略，即后面讲的三种都是建立在逃逸分析之后的结论进行优化的

逃逸分析包括：

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

例如：

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 static StringBuffer craeteStringBuffer(String s1， String s2) {
      
      
	StringBuffer sb = new StringBuffer();
	sb.append(s1);
	sb.append(s2);
	return sb;
}
```
StringBuffer sb是一个方法内部变量，上述代码中直接将sb返回，这样这个StringBuffer有可能被其他方法所改变，这样它的作用域就不只是在方法内部，虽然它是一个局部变量，称其逃逸到了方法外部。甚至还有可能被外部线程访问到，譬如赋值给类变量或可以在其他线程中访问的实例变量，称为线程逃逸。

上述代码如果想要StringBuffer sb不逃出方法，可以这样写：
```
public static String createStringBuffer(String s1， String s2) {
      
      
	StringBuffer sb = new StringBuffer();
	sb.append(s1);
	sb.append(s2);
	return sb.toString();
}
```
不直接返回 StringBuffer，那么StringBuffer将不会逃逸出方法。

使用逃逸分析，编译器可以对代码做如下优化：

一、同步省略。如果一个对象被发现只能从一个线程被访问到，那么对于这个对象的操作可以不考虑同步。
二、将堆内存分配转化为栈内存分配。如果一个对象在子程序中被分配，要使指向该对象的指针永远不会逃逸，对象可能是栈分配的候选，而不是堆分配。
三、分离对象或标量替换。有的对象可能不需要作为一个连续的内存结构存在也可以被访问到，那么对象的部分（或全部）可以不存储在内存，而是存储在CPU寄存器中。

在Java代码运行时，通过JVM参数可指定是否开启逃逸分析

-XX:+DoEscapeAnalysis ：表示开启逃逸分析
-XX:-DoEscapeAnalysis ：表示关闭逃逸分析

从jdk 1.7开始已经默认开启逃逸分析，如需关闭，需要指定 -XX:-DoEscapeAnalysis

3.4 对象的栈上内存分配

我们知道，在一般情况下，对象和数组元素的内存分配是在堆内存上进行的。但是随着JIT编译器的日渐成熟，很多优化使这种分配策略并不绝对。JIT编译器就可以在编译期间根据逃逸分析的结果，来决定是否可以将对象的内存分配从堆转化为栈。

我们来看以下代码：

public class EscapeAnalysisTest {
    
    

	public static void main(String[] args) {
    
    
		long a1 = System.currentTimeMillis();
		for (int i = 0; i < 1000000; i++) {
    
    
			alloc();
		}
		// 查看执行时间
		long a2 = System.currentTimeMillis();
		System.out.println("cost " + (a2 - a1) + " ms");
		// 为了方便查看堆内存中对象个数，线程sleep
		try {
    
    
			Thread.sleep(100000);
		} catch (InterruptedException e1) {
    
    
			e1.printStackTrace();
		}
	}
	// 此方法内的User对象，未发生逃逸
	private static void alloc() {
    
    
		User user = new User();
	}
	
	static class User {
    
    
	}
}

其实代码内容很简单，就是使用for循环，在代码中创建100万个User对象。

我们在alloc方法中定义了User对象，但是并没有在方法外部引用他。也就是说，这个对象并不会逃逸到alloc外部。经过JIT的逃逸分析之后，就可以对其内存分配进行优化。

我们指定以下JVM参数并运行：

-Xmx4G -Xms4G -XX:-DoEscapeAnalysis -XX:+PrintGCDetails -XX:+HeapDumpOnOutOfMemoryError

在程序打印出 cost XX ms 后，代码运行结束之前，我们使用jmap命令，来查看下当前堆内存中有多少个User对象：

~ jps
2809 StackAllocTest
2810 Jps
~ jmap -histo 2809
num #instances #bytes class name
----------------------------------------------
1: 524 87282184 [I
2: 1000000 16000000 StackAllocTest$User
3: 6806 2093136 [B
4: 8006 1320872 [C
5: 4188 100512 java.lang.String
6: 581 66304 java.lang.Class

从上面的jmap执行结果中我们可以看到，堆中共创建了100万个 StackAllocTest$User 实例。
在关闭逃避分析的情况下（-XX:-DoEscapeAnalysis），虽然在alloc方法中创建的User对象并没有逃逸到方法外部，但是还是被分配在堆内存中。也就说，如果没有JIT编译器优化，没有逃逸分析技术，正常情况下就应该是这样的。即所有对象都分配到堆内存中。

接下来，我们开启逃逸分析，再来执行下以上代码。

-Xmx4G -Xms4G -XX:+DoEscapeAnalysis -XX:+PrintGCDetails -XX:+HeapDumpOnOutOfMemoryError

在程序打印出 cost XX ms 后，代码运行结束之前，我们使用 jmap 命令，来查看下当前堆内存中有多少个User对象：

~ jps
709
2858 Launcher
2859 StackAllocTest
2860 Jps
~ jmap -histo 2859
num #instances #bytes class name
---------------------------------------------
1: 524 101944280 [I
2: 6806 2093136 [B
3: 83619 1337904 StackAllocTest$User
4: 8006 1320872 [C
5: 4188 100512 java.lang.String
6: 581 66304 java.lang.Class

从以上打印结果中可以发现，开启了逃逸分析之后（-XX:+DoEscapeAnalysis），在堆内存中只有8万多个 StackAllocTest$User 对象。也就是说在经过JIT优化之后，堆内存中分配的对象数量，从100万降到了8万。
除了以上通过jmap验证对象个数的方法以外，还可以尝试将堆内存调小，然后执行以上代码，根据GC的次数来分析，也能发现，开启了逃逸分析之后，在运行期间，GC次数会明显减少。正是因为很多堆上分配被优化成了栈上分配，所以GC次数有了明显的减少。

并不是完全都在栈上内存分配，因为栈上内存分配也有可能把栈内存空间撑满了

另外逃逸分析是建立在JIT编译的时候，而JIT编译只会针对热点代码，默认执行1W次以上的方法或循环体

总结
所以，如果以后再有人问你：是不是所有的对象和数组都会在堆内存分配空间？

那么你可以告诉他：不一定，随着JIT编译器的发展，在编译期间，如果JIT经过逃逸分析，发现有些对象没有逃逸出方法，那么有可能堆内存分配会被优化成栈内存分配。但是这也并不是绝对的。就像我们前面看到的一样，在开启逃逸分析之后，也并不是所有User对象都没有在堆上分配。

3.5 标量替换

标量（Scalar）是指一个无法再分解成更小的数据的数据。

标量就是基本数据类型和引用类型，相反就是聚集量，指对象
标量替换的意思就是将对象拆解成多个标量进行存储

好处，首先看下对象的布局，对象在堆里面有三块布局区域：

对象头

实例数据区域

对齐填充

我们可能真正需要的只有实例数据区域的数据，但是另外两块也占据内存，但是都没用到对象用被标量替换后，就相当于只需有实例空间内存区域就行了，而且这块内存区域也不在堆里面而在栈里面，减轻gc回收压力

在JIT阶段，如果经过逃逸分析，发现一个对象不会被外界访问的话，那么经过JIT优化，就会把这个对象拆解成若干个其中包含的若干个成员变量来代替。

//有一个类A
public class A{
    
    
	public int a=1;
	public int b=2
}
//方法getAB使用类A里面的a，b
private void getAB(){
    
    
	A x = new A();
	x.a;
	x.b;
}
//JVM在编译的时候会直接编译成
private void getAB(){
    
    
	a = 1;
	b = 2;
}

这就是标量替换

有效降低内存消耗

3.6 同步锁消除

同样基于逃逸分析，当加锁的变量不会发生逃逸，是线程私有的完全没有必要加锁。在JIT编译时期就可以将同步锁去掉，以减少加锁与解锁造成的资源开销。

public class TestLockEliminate {
    
    

	public static String getString(String s1， String s2) {
    
    
		StringBuffer sb = new StringBuffer();
		sb.append(s1);
		sb.append(s2);
		return sb.toString();
	}
	
	public static void main(String[] args) {
    
    
		long tsStart = System.currentTimeMillis();
		for (int i = 0; i < 100000000; i++) {
    
    
			getString("TestLockEliminate "， "Suffix");
		}
		System.out.println("一共耗费：" + (System.currentTimeMillis() - tsStart) + " ms");
	}
}

getString()方法中的StringBuffer是函数内部的局部变量，作用于方法内部，不可能逃逸出该方法，因此他就不可能被多个线程同时访问，也就没有资源的竞争，但是StringBuffer的append操作却需要执行同步操作，代码如下:

@Override
public synchronized StringBuffer append(String str) {
    
    
	toStringCache = null;
	super.append(str);
	return this;
}

逃逸分析和锁消除分别可以使用参数 -XX:+DoEscapeAnalysis 和 -XX:+EliminateLocks (锁消除必须在-server模式下)开启。使用如下参数运行上面的程序：

-XX:+DoEscapeAnalysis -XX:-EliminateLocks

得到如下结果：

使用如下命令运行程序：

-XX:+DoEscapeAnalysis -XX:+EliminateLocks