JVM深入学习笔记二：Java JIT编译

JIT是java虚拟机把热点字节码编译成机器码的技术。

解释执行，在当运行次数比较少的时候能够省去编译的操作直接运行字节码。  另外解释更加的节约内存。

而编译为机器码则可以获得更高的效率。

因为各有好处，HotSpot使用了共存的机制，可以使用-Xint强制使用解释模式或者是-Xcomp 编译模式。

此外HotSpot提供了两种编译器Client Compile和Server Compiler,分别针对于更快的编译速度和更好的编译效果。使用-client或者-server参数指定

在这种共存模式下HotSpot使用分层编译的概念，

0：解释执行，不开启性能监控，

1：也成为C1编译，字节码便以为机器码，简单优化，加入必要的性能监控逻辑

2：C2编译， 加入更多的优化。

如何判断热点

HotSpot会对调用多次的方法和执行多次的循环体作为热点，然后便以为本地机器码。  

判断的算法使用基于计数器的热点探测。

在执行的时候给方法加入调用计数器和回边计数器，如果超过阈值则触发JIT，  用-XX:ComplileThreshold来指定阈值。

热度衰减，  多长时间内没有调用方法则计数器减半的方式，  -XX:-UseCounterDecay 关闭   -XX:CounterHalfLifeTime设置周期

编译行为做了什么

C1， 三段式编译

1. 字节码  ->  方法内联、常量传播等优化  -> HIR  一种高级中间码，为了更好的优化

2. HIR       -> 空置检查清除等                     -> LIR 低级中间码

3. LIR       -> 分配寄存器， 做窥孔优化(一种小范围优化，通常是根据CPU指令集进行一些优化，比如重排命令顺序等)  -> 本地机器码

C2  的优化就非常多了。

查看JIT执行情况

public class TestJit {
	public static final int TIMES = 15000;
	public static int doubleValue(int i){
		return i * 2;
	}
	
	public static long calcSum(){
		long sum = 0;
		for (int i = 0; i < 100; i++) {
			sum += doubleValue(i);
		}
		
		return sum;
	}
	
	public static void main(String[] args) {
		for (int i = 0; i < TIMES; i++) {
			calcSum();
		}
	}
}

calcSum和doubleValue都被执行了很多次，应该执行JIT。

main中的循环执行了很多次，应该执行JIT，

运行的时候加入-XX:+PrintCompilation参数查看执行了JIT的方法:

     43   3       com.prince.jvmtest.TestJit::doubleValue (4 bytes)
     43   4       com.prince.jvmtest.TestJit::calcSum (26 bytes)
     46   1%      com.prince.jvmtest.TestJit::main @ 5 (20 bytes)

带%号的就是栈替换编译OSR。

出了打印这些信息外，还能够打印方法内联，字节码生成等等的信息但是需要debug版本的JDK了，这个以后有时间了再看。

debug版本JD可下载地址：https://jdk6.java.net/download.html

各种优化技术

public class TestJit {
	public void foo(){
		B b = new B();
		int y = b.get();
		int z = b.get();
		int add = y + z;
	}
}

class B{
	public int value;
	final int get(){
		return value;
	}
}

这一段会执行如下的优化：

1. 方法内联

减少方法调用，内联为更大的方法之后可以适用于其他的优化方式，因此会处于编译器比较靠前的位置

把b.get(),转化为b.value

final ,private,static的可以内联优化。

另外因为Java主张面向对象的方式编程，大部分方法都是虚方法，对于虚方法就要确定可以使用的真实代码的份数，如果只有一个那么也是可以内联的。

2. 去掉冗余 y = b.get()与z = b.get()重复了，会转化为z=y,然后add=y+z直接就回替换为add=y+y,在删除z=y.

int sum = (b * c) * 12 + a + (a + b * c)

3. 表达式简化。会被优化为 (b * c) * 13 + a * 2

4. 数组越界检查清除。    比如a[3]是个固定的值，而在流分析中能够知道a的长度是大于3的，这样的话就不会加上边界检查。

逃逸分析。         辅助别的优化技术的技术。   当一个对象定义后可能作为参数传给其他的方法，或者是作为构造器参数传给别的类甚至线程，这成为可逃逸的。

对于不可逃逸的就可以进行下列优化了

5. 栈上分配，如果一个对象不可逃逸，那么放在栈上能够随着入栈出栈而自动清除就会减少系统回收的压力

6. 同步消除，如果能够证明其不会逃逸出一个线程，那个同步的代码可以被清除掉

7. 标量替换，不能分解的叫做标量，对象是聚合量，如果逃逸分析证明一个对象不会被外部访问，且这个对象可以被分解为标量，那么可能不创建这个对象，知识创建一些标量

Java的即时编译器与静态编译器的对比

1. 即时编译器运行于程序运行期间，因此会给程序运行带来压力，而静态编译器不会太考虑时间成本。

2. 因为java有很多运行期的动态机制，这使得虚拟机会做很多动态检查，比如数组越界，空指针等，如果没有写出明确的检查行为代码，编译器就会做优化，会耗费很多运行时间。因此我们写代码的时候要尽量自己把这些检查加进去

3. Java的多态很多，会加大方法内联的难度

4. 因为Java能够动态扩展，因此全局优化很难进行，即使进行了也要在运行时做出撤销或者重新优化的设计

5. Java在堆上分配对象，而C等语言可以对内存使用更加灵活。因此速度回慢一些。

这些问题都是Java为了提高开发效率而付出的代价。

另外Java有自己的优势。 JIT能够进行运行期性能监控为基础的优化措施，这是静态编译无法做到的。