深入理解JVM虚拟机(八)：编译器优化

本博客从编译期源码实现的层次上让我们了解了Java源代码编译为字节码的过程，分析了Java语言中泛型、主动装箱/拆箱、条件编译等多种语法糖的前因后果。

1. 概述

java语言的“编译期”其实是一段“不确定”的操作过程，因为它可能是指一个前端编译器（其实叫“编译器的前端”更准确点）把*.java文件转化为*.class文件的过程；也可能是指虚拟机的后端运行期编译器（JIT编译器，Just In Time Compiler）把字节码转化为机器码的过程；还可能是指使用静态提前编译器（AOT编译器，Ahead Of Time Compiler）直接把*.java文件编译成本地机器代码的过程。下面列举了这3类编译过程中一些比较有代表性的编译器。

1. 前段编译器：Sun的Javac、Eclipse JDT中的增量式编译器（ECJ）；
2. JIT编译器：GNU Compiler for the Java（GCJ）、Excelsior JET；
3. AOT编译器：GNU Compiler for the Java（GCJ）、Excelsior JET；

2. Javac编译器

Javac编译器不像HotSpot虚拟机那样使用C++语言（包含C少量C语言）实现，它本身就是一个由Java语言编写的程序，这为纯Java的程序员了解它的编译过程带来了很大的便利。

Javac编译器大致上可以分为三个过程，分别是：

1. 解析与填充符合表过程；
2. 插入式注解处理器的注解处理过程；
3. 语义分析与字节码生成过程。

这三个步骤之间的关系与交互顺序如图所示：

2.1 解析与填充符号表

2.1.1 词法、语法分析

词法分析是将源代码的字符流转变为标记（Token）集合，单个字符是程序编写过程的最小元素，而标记则是编译过程的最小元素，关键字、变量名、字面量、运算符都可以成为标记，如“int a = b + 2”这句代码包含了6个标记，分别是int、a、=、b、+、2，虽然关键字int由3个字符构成，但是它只是一个Token，不可再拆分。在Javac的源码中，词法分析过程由com.sun.tools.javac.parser.Scanner类来实现。

语法分析是根据Token序列构造抽象语法树的过程，抽象语法树（Abstract Syntax Tree，AST）是一种用来描述程序代码语法结构的树形表示方式，语法树的每一个阶段都代表着程序代码中的一个语法结构（Construct），例如包、类型、修饰符、运算符、接口、返回值甚至代码注释等都可以是一个语法结构。

2.1.2 填充符号表

完成了语法分析和词法分析之后，下一步就是填充符号表的过程。符号表（Symbol Table）是由一组符号地址和符号信息构成的表格，读者可以把它想象成哈希表中K-V值对的形式（实际上符号表不一定是哈希表实现，可以是有序号表、树状符号表、栈结构符号表等）。符号表中所登记的信息在编译的不同阶段都要用到。在语义分析中，符号表所登记的内容将用于语义检查（如检查一个名字的使用和原先的说明是否一致）和产生中间代码。在目标代码生成阶段，当对符号名进行地质分配时，符号表是地址分配的依据。

2.2 注解处理器

在JDK1.5之后，Java语言提供了对注解（Annotation）的支持，这些注解与普通的Java代码一样，是在运行期间发挥作用的。在JDK1.6中实现了JSR-269规范，提供了一组插入式注解处理器的标准API在编译期间对注解进行处理，我们可以把它看做是一组编译器的插件，在这些插件里面，可以读取、修改、添加抽象语法树中的任意元素。如果这些插件在处理注解期间对语法树进行了修改，编译器将回到解析及填充符号表的过程重新处理，直到所有插入式注解处理器都没有再对语法树进行修改为止，每一次循环称为一个Round，也就是上图中的回环过程。

有了编译器注解处理的标准API后，我们的代码才有可能干涉编译器的行为，由于语法树中的任意元素，甚至包括代码注释都可以在插件之中访问到，所以通过插入式注解处理器实现的插件在功能上有很大的发挥空间。只要有足够的创意，程序员可以使用插入式注解处理器来实现许多原本只能在编码中完成的事情，本章最后会给出一个使用插入式注解处理器的简单实战

2.3 语义分析与字节码生成

语法分析之后，编译器获得了程序代码的抽象语法树表示，语法树能表示一个结构正确的源程序的抽象，但无法保证源程序是符合逻辑的。而语义分析的主要任务是对结构上正确的源程序进行上下文有关性质的审查，如进行类型审查。举个例子，假设有如下的3个变量定义语句：

int a = 1;
boolean b = false;
char c = 2;

后续可能出现的赋值运算：

int d = a + c;
int d = b + c;
char d = a + c;

后续代码中如果出现了如上3中赋值运算的话，那它们都能构成结构正确的语法树，但是只有第一种的写法在语义上是没有问题的，能够通过编译，其余两种在Java语言中是不合逻辑的，无法编译（是否合乎语义逻辑必须限定在具体的语言与具体的上下文环境之中才有意义。如在C语言中，a、b、c的上下文定义不变，第2、3种写法都是可以正确编译）。所以我们就需要进行语义分析，javac编译器中语义分析包括三个步骤：标注检查、数据及控制流分析、解语法糖。

2.3.1 标注检查

Javac的编译过程中，语义分析过程分为标注检查以及数据及控制流分析两个步骤。

标注检查步骤检查的内容包括诸如变量使用前是否已被声明、变量与赋值之间的数据类型是否能够匹配等。在标注检查步骤中，还有一个重要的动作称为常量折叠。

2.3.2 数据及控制流分析

数据及控制流分析是对程序上下文逻辑更进一步的验证，它可以检查出诸如程序局部变量在使用前是否有赋值、方法的每条路径是否都有返回值、是否所有的受查异常都被正确处理了等问题。编译时期的数据及控制流分析与类加载时的数据及控制流分析的目的基本上是一致的，但校验范围有所区别，有一些校验项只有在编译期或运行期才能进行。

2.3.3 解语法糖

语法糖（System Sugar），也成糖衣语法，是由英国计算机科学家彼得-约翰-兰达（Peter J.Landin）发明的一个术语，指在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。通常来说，使用语法糖能够增加程序的可读性，从而减少程序代码出粗的机会。

Java在现代编程语言之中属于“低糖语言”（相对于C#及许多其他JVM语言来说），尤其是JDK1.5之前的版本，“低糖”语法也是Java语言被怀疑已经“落后”的一个表面理由。Java中最常用的语法糖主要是前面提到过的泛型（泛型并不一定都是语法糖实现，如C#的泛型就是直接由CLP支持的）、变长参数、自动装箱/拆箱等，虚拟机运行时不支持这些语法，它们在编译阶段还原回简单地基础语法结构，这个过程称为解语法糖。Java的这些语法糖被解除后是什么样子，我们将在下一个章节进行介绍。

2.3.4 字节码生成

字节码生成是Javac编译过程的最后一个阶段，在Javac源码里面由com.sun.tools.javac.jvm.Gen类来完成。字节码生成阶段不仅仅是把前面各个步骤所生成的信息（语法树、符号表）转化成字节码写到磁盘中，编译器还进行了少量的代码添加和转换工作。

例如，前面章节中多次提到的实例构造器（）方法和类构造器（）方法就是在这个阶段添加到语法树之中的（注意，这里的实例构造器并不是指默认构造函数，如果用户代码中没有提供任何构造函数，那编译器将会添加一个没有参数的、访问性（public、protected或private）与当前类一致的默认构造函数，这个工作在填充符号表阶段就已经完成），这两个构造器的产生过程实际上是一个代码收敛的过程，编译器会把语句块（对于实例构造器而言是“{}”块，对于类构造器而言是“static{}”块）、变量初始化（实例变量和类变量）、调用父类的实例构造器（仅仅是实例构造器，()方法中无须调用父类的()方法，虚拟机会自动保证父类构造器的执行，但在()方法中经常会调用java.lang.Object的()方法的代码）等操作收敛到()和()方法之中，并且保证一定是按先执行父类的实例构造器，然后初始化变量，最后执行语句块的顺序进行，上面所述的动作由Gen.normalizeDefs()方法来实现。

3. Java语法糖

Java语法糖主要包括泛型擦除、自动装箱和自动拆箱、以及遍历循环和条件编译。

3.1 泛型与类型擦除

泛型是JDK1.5的一项新增特性，它的本质是参数化类型（Parametersized Type）的应用，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口和泛型方法。

下面一段简单的Java泛型的例子，我们可以看一下它编译后的结果是怎样的。

//10-2  泛型擦除前的例子
public static void main(String []args){
        Map<String, String> map = new HashMap<String, String>();
        map.put("hello", "您好");
        map.put("how are you?", "吃了没？");
        System.out.println(map.get("hello"));
        System.out.println(map.get("how are you?"));
}

这段代码编译成Class文件，然后再用字节码反编译工具进行反编译后，将会发现泛型都不见了，程序又变回了Java泛型出现之前的写法，泛型类型都变回了原生类型。

//代码清单10-3  泛型擦除后的样子
	public static void main(String[] args) {
		Map map = new HashMap();
		map.put("hello", "你好,");
		map.put("how are you!", "吃了么?");
		System.out.println((String)map.get("hello"));
		System.out.println((String)map.get("how are you!"));
	}

我们来看一下方法重载的代码,下面重载的代码方法是不可以编译的，因为由于泛型擦除，变成了一样的原生类型List，擦除动作导致这两种方法的特征签名变得一模一样。

/**
 * 代码清单10-4
 * 当泛型遇到重载 1
 * @author Peter
 *
 */
public class GenericTypes {
 
	public static void method(List<String> list){
		System.out.println("invoke method(List<String> list)");
	}
	
	public static void method(List<Integer> list){
		System.out.println("invoke method(List<Integer> list)");
	}
}

下面我们再来看一下方法重载的代码：

/**
 * 代码清单10-5
 * 当泛型遇到重载2
 * @author Peter
 *
 */
public class GenericTypes1 {
 
	public static String method(List<String> lits){
		System.out.println("invoke method(List<String> list)");
		return "";
	}
	
	public static int method(List<Integer> list){
		System.out.println("invoke method(List<Integer> list)");
		return 1;
	}
	
	public static void main(String[] args) {
		method(new ArrayList<String>());
		method(new ArrayList<Integer>());
	}
}

两个method方法添加了不同的返回值，由于这两个返回值的加入，方法重载居然成功了，即这段代码可以被编译和执行了。

Class文件方法表（method_info）的数据结构时曾经提到过，方法重载要求方法具备不同的特征签名，返回值并不包含在方法的特征签名之中，所以返回值不参与重载选择，但是在Class文件格式之中，只要描述符不是完全一致的两个方法就可以共存。也就是说，两个方法如果有相同的名称和特征签名，但返回值不同，那它们也是可以合法地共存于一个Class文件中的。

3.3 自动装箱、自动拆箱与遍历循环

从纯技术的角度来讲，自动装箱、自动拆箱与遍历循环（Foreach循环）这些语法糖，无论是实现上还是思想上都不能和上文介绍的泛型相比，两个的难度和深度都有很大的差距。它们是Java语言里使用得最多的语法糖。

下面我们来通过一个例子来理解自动装箱、自动拆箱与遍历循环。

/**
 * 代码清单10-6
 * 自动装箱、拆箱与遍历循环
 * @author Peter
 *
 */
public class Test03 {
 
	public static void main(String []args){
		
		List<Integer> list = Arrays.asList(1, 2, 3, 4);
		//如果在JDK1.7中，还有另外一种语法糖
		//能让上面这句代码进一步简写成List<Integer> list = [1, 2, 3, 4];
		int sum = 0;
		for(int i : list){
			sum += i;
		}
		System.out.println(sum);
	}
}

在经过编译器编译之后，Java语法糖拆解之后的代码：

/**
 * 代码清单10-7
 * 自动装箱、拆箱与遍历循环编译之后
 * @author Peter
 *
 */
public class Test04 {
	
	public static void main(String[] args) {
		List list = Arrays.asList(new Integer[]{
			Integer.valueOf(1),
			Integer.valueOf(2),
			Integer.valueOf(3),
			Integer.valueOf(4)
		});
		int sum = 0;
		for(Iterator localIterator = list.iterator(); localIterator.hasNext();){
			int i = ((Integer) localIterator.next()).intValue();
			sum += i;
		}
		System.out.println(sum);
	}
}

我们可以看出：

1.自动装箱

Integer a=1;
//编译器优化
Integer a=new Integer(1);

2.自动拆箱

Integer a=1;
int i = a+2;
//编译器优化
Integer a=new Integer(1);
int i= a.intValue()+2;

3.循环编译

List<Integer> list = Arrays.asList(1, 2, 3, 4);
for(int i : list){

}
//编译器优化
List list = Arrays.asList(new Integer[]{
			Integer.valueOf(1),
			Integer.valueOf(2),
			Integer.valueOf(3),
			Integer.valueOf(4)
});
for(Iterator localIterator = list.iterator(); localIterator.hasNext();){

}

3.4 条件编译

许多程序设计语言都提供了条件编译的途径，如C、C++中使用预处理指示符（#ifdef）来完成条件编译。C、C++的预处理器最初的任务是解决编译时的代码依赖关系（如非常常用的#include预处理命令），而在Java语言之中并没有使用预处理器，因为Java语言天然的编译方式（编译器并非一个个地编译Java文件，而是将所有编译单元的语法树顶级节点输入到待处理列表后再进行编译，因此各个文件之间能够互相提供符号信息）无须使用预处理器。

Java语言当然也可以进行条件编译，方法就是使用条件为常量的if语句

下面我们来看一下Java条件编译的用法：

/**
 * 代码清单10-9 Java语言的条件编译
 * @author Peter
 *
 */
public class Test06 {
	
	public static void main(String[] args) {
		if(true){
			System.out.println("block 1");
		}else{
			System.out.println("block 2");
		}
	}
}

Java条件编译优化后的代码：

public class Test06 {
	public static void main(String[] args) {
		System.out.println("block 1");
	}
}

Java语言中条件编译的实现，也是Java语言的一颗语法糖，根据布尔常量值的真假，编译器将会把分支中不成立的代码块消除掉，这一工作将在编译器解除语法糖阶段（com.sun.tools.javac.comp.Lower类中）完成。