Java虚拟机早期(编译期)优化

概述

Java的编译期可能是一个前端编译器把.java变成.class的过程，也可能是虚拟机的后端运行期编译器(JIT编译器，Just In Time Compiler)把字节码转换成机器码的过程。还可能是使用静态提前编译器(AOT编译器，Ahead Of Time Compiler)直接把.java文件编译成本地机器代码的过程。本文的编译期和编译期都指第一类编译期。

Javac这类编译器对代码的运行效率几乎没有任何优化措施，虚拟机设计团队把对性能的优化集中到了后端的即时编译器中，这样可以让那些不是Javac编译的Class文件也能享受到编译器优化带来的好处。但是Javac做了许多针对Java语言编码过程的优化措施来改善程序员的编码风格和提高编码效率。Java中即时编译器在运行期的优化过程对于程序运行更重要，而前端编译器(Javac)在编译期的优化过程对于程序编码来说关系更加密切。

Javac编译器

Javac是由Java编写的程序。从Javac代码来看，编译过程大致可以分为三个过程：

• 解析与填充符号表过程；
• 插入式注解处理器的注解处理过程；
• 分析与字节码生成过程。

javac编译动作的入口是com.sun.tools.javac.main.JavaCompiler类，上述三个过程的代码逻辑集中在这个类的compile()和compile2()方法中，以下是各个方法分析。

解析与填充符号表

解析步骤由parseFiles()方法完成，包括词法分析和语法分析。

词法、语法分析

词法分析是将源代码的字符流转变为标记(Token)集合，单个字符是程序编写过程的最小元素，而标记则是编译过程的最小元素，关键字、变量名、字面量、运算符都可以成为标记，虽然关键字由几个字符构成，但它只是一个Token，词法分析过程由com.sun.tools.javac.parser.Scanner类来实现。

语法分析是根据Token序列构造抽象语法树(Abstract Syntax Tree，AST)的过程，抽象语法树是一种用来描述程序代码语法结构的树形表示方式，语法树的每一个节点都代表着程序代码中的一个语法结构(Construct)，例如包、类型、修饰符、运算符、接口、返回值甚至代码注释都可以是一个语法结构。语法分析过程是由com.sun.tools.javac.parser.Parser类实现。经过这个步骤之后，编译器基本不会对源码文件进行操作了，后续的操作都建立在抽象语法树之上。

填充符号表

词法分析和语法分析之后是填充符号表的过程。由enterTrees()方法完成。符号表(Symbol Table)是一组由符号地址和符号信息所构成的表格，可以把它看作哈希表K-V值对的形式，符号表中所登记的信息在编译的不同阶段都要用到。在语义分析中，符号表所登记的内容将用于语义检查和产生中间代码，在目标代码生成阶段，当对符号名进行地址分配时，符号表是地址分配的依据。填充符号表的过程由com.sun.tools.javac.comp.Enter类实现，此过程的出口是一个待处理列表(To Do List)，包含了每一个编译单元的抽象语法树的顶级节点，以及package-info.java的顶级节点。

注解(Annotation)处理器

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

在Javac源码中，插入式注解处理器的初始化过程是在initProcessAnnotation()方法中完成的，这个方法判断是否还有新的注解处理器需要执行，如果有的话，通过com.sun.tools.javac.processing.JavacProcessingEnvironment类的doProcessing()方法生成一个新的JavaCompiler对象对编译的后续步骤进行处理。

语义分析与字节码生成

抽象语法树不能保证源程序逻辑是正确的，语义分析的主要任务是对结构上正确的源程序进行上下文有关性质的审查，如进行类型审查。语义分析过程分为标注检查以及数据及控制流分析两个步骤，对应attribute()和flow()方法。

• 标注检查：标注检查内容包括诸如变量使用前是否已被声明、变量与赋值之间的数据类型是否能够匹配等。还有一个动作称为常量折叠。如int a = 1+2，常量折叠会把a=3的值在语法树上标注出来。标注检查的实现类是sun.tools.javac.comp.Attr类和com.sun.tools.javac.comp.Check类。
• 数据及控制流分析：数据及控制流分析是对程序上下文逻辑更进一步的验证，它可以检查出诸如程序局部变量在使用前是否有赋值、方法的每条路径是否都有返回值、是否所有的受查异常都被正确处理了等问题。
• 解语法糖：语法糖(Syntactic Sugar)，指在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。Java中常用的语法糖有泛型、变长参数、自动装箱拆箱等，虚拟机运行时不支持这些语法，它们在编译阶段还原回简单的基础语法结构，这个过程称为解语法糖。解语法糖由desugar()方法触发，在com.sun.tools.javac.comp.TransType类和com.sun.tools.javac.comp.Lower类完成。
• 字节码生成：字节码生成是编译的最后一个阶段，由com.sun.tools.javac.jvm.Gen类完成。字节码生成阶段不仅仅是将前面各个步骤生成的信息转换成字节码写到磁盘里，编译器还进行了少量的代码添加和转换工作。这个阶段会把实例构造器(())和类构造器(())方法添加到语法树中，此外，还有一些代码替换工作来优化程序实现逻辑，如把字符串加操作替换为StringBuilder或StringBuffer的append()操作等。完成语法树遍历和调整之后，把填充了所需信息的符号表交给com.sun.tools.javac.jvm.ClassWriter类，由这个类的writeClass()方法输出字节码，生成最终的Class文件，至此，编译过程宣告结束。

Java语法糖

泛型与类型擦除

泛型的本质上参数化类型(Parametersized Type)的应用，这种类型可以用在类、接口和方法的创建中，称为泛型类、泛型接口和泛型方法。

在1.5版本之前，只能用Object和类型强制转换来实现类型泛化，在编译期间，编译器无法检查这个Object是否转型成功，在程序运行期会出现ClassCastException的风险。

Java中的泛型在编译后的字节码文件就已经被替换为原生类型了，并且在相应的地方插入了强制转型代码，所以对运行期的Java来说，ArrayList和ArrayList是一个类，泛型技术实际上是一颗语法糖，Java中泛型实现方法称为类型擦除，基于这种方法实现的泛型称为伪泛型。

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

看下面一段代码：

import java.util.Arrays;
import java.util.List;

/**
 * @author Zhang
 * @date 2018/8/23
 * @Description
 */
public class BoxingTest {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4);

        int sum = 0;
        for(int i: list){
            sum += i;
        }

        System.out.println(sum);
    }
}

编译后用jd-gui反编译出来的代码是这样的：

import java.io.PrintStream;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class BoxingTest
{
  public static void main(String[] args)
  {
    List<Integer> 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);
  }
}

上述代码包含了泛型、自动拆箱装箱、遍历循环和变长参数这几个语法糖。自动装箱、拆箱在编译后被转化成了对应的包装盒还原方法，如Integer.value()方法和Integer.intValue()方法，遍历循环则变成了迭代器的实现。而变长参数变成了一个数组。

public class BoxingAbout {
    public static void main(String[] args) {
        Integer a = 1;
        Integer b = 2;
        Integer c = 3;
        Integer d = 3;
        Integer e = 321;
        Integer f = 321;
        Long g = 3L;
        System.out.println(c == d);
        System.out.println(e == f);
        System.out.println(c == (a+b));
        System.out.println(c.equals(a+b));
        System.out.println(g == (a+b));
        System.out.println(g.equals(a+b));
    }
}

把上面的代码去语法糖如下：

public class BoxingAbout
{
  public static void main(String[] args)
  {
    Integer a = Integer.valueOf(1);
    Integer b = Integer.valueOf(2);
    Integer c = Integer.valueOf(3);
    Integer d = Integer.valueOf(3);
    Integer e = Integer.valueOf(321);
    Integer f = Integer.valueOf(321);
    Long g = Long.valueOf(3L);
    System.out.println(c == d);
    System.out.println(e == f);
    System.out.println(c.intValue() == a.intValue() + b.intValue());
    System.out.println(c.equals(Integer.valueOf(a.intValue() + b.intValue())));
    System.out.println(g.longValue() == a.intValue() + b.intValue());
    System.out.println(g.equals(Integer.valueOf(a.intValue() + b.intValue())));
  }
}

可以看到，在“==”运算，如果不遇到算术运算，不会自动拆箱，有算数运算会自动拆箱，而“equals”方法只会处理自动装箱，不会处理类型转换。Integer.valuOf源码如下：

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

IntegerCache.cache是一个长度256的Integer数组，记录了-128~127，所以在这个范围内的数装箱以后会返回缓冲数组中的Integer对象，其余的数就要新建Integer对象了。Short、Long的valueOf方法也是这样的。答案也显而易见了。

条件编译

Java中使用条件为常量的if语句能实现条件编译。

public class PreCompile {
    public static void main(String[] args) {
        if(true){
            System.out.println("1");
        }
        else {
            System.out.println("2");
        }
    }
}

反编译代码如下：

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

条件为常量的if语句在编译阶段就会“运行”，生成的字节码只包括其中一条，这其实也是一颗语法糖。

除此之外，Java还有许多语法糖，如内部类、枚举类、断言等，可通过反编译和源码分析。