JVM笔记-前端编译与优化

WriteOnRead

发布于 2020-04-22 16:23:45

4370

发布于 2020-04-22 16:23:45

文章被收录于专栏：WriteOnReadWriteOnRead

1. 概述

所谓”编译“，通俗来讲就是把我们写的代码“翻译“成机器可以读懂的机器码。而编译器就是做这个翻译工作的。

Java 技术中的编译器可以分为如下三类：

前端编译器：把 *.java 文件转变为 *.class 文件的过程。比如 JDK 的 Javac。
即时编译器：Just In Time Compiler，常称 JIT 编译器，在「运行期」把字节码转变为本地机器码的过程。比如 HotSpot VM 的 C1、C2 编译器，Graal 编译器。
提前编译器：Ahead Of Time Compiler，常称 AOT 编译器，直接把程序编译成与目标机器指令集相关的二进制代码的过程。比如 JDK 的 Jaotc，GNU Compiler for the Java。

其中后面两类都属于后端编译器。

本文主要分析前端编译器 Javac 的相关内容，后文再介绍后端编译器。

2. Javac 编译器

Javac 的编译过程大致可以分为 1 个准备过程和 3 个处理过程：

准备过程：初始化插入式注解处理器
解析与填充符号表过程
1. 词法、语法分析：将源码中的字符流转变为标记集合，构造抽象语法树
2. 填充符号表：产生符号地址和符号信息
插入式注解处理器的注解处理过程
分析与字节码生成过程
1. 标注检查：对语法的静态信息进行检查
2. 数据流及控制流分析：对程序的动态运行过程进行检查
3. 解语法糖：将简化代码编写的语法糖还原为原来的样子
4. 字节码生成：将前面各个步骤所生成的信息转化为字节码

2.1 解析与填充符号表

2.1.1 词法、语法分析

词法分析

将源码中的字符流转变为标记（Token）集合的过程。关键字、变量名、运算符等都可作为标记。比如下面一行代码：

int a = b + 2;

在字符流中，关键字 int 由三个字符组成，但它是一个独立的标记，不可再分。

该过程有点类似“分词”的过程。虽然这些代码我们一眼就能认出来，但编译器要逐个分析过之后才能知道。

语法分析

根据上面的标记序列构造抽象语法树的过程。

抽象语法树（Abstract Syntax Tree，AST）是一种用来描述程序代码语法结构的树形表示方法，每个节点都代表程序代码中的一个语法结构（Syntax Construct），比如包、类型、修饰符等。

通俗来讲，词法分析就是对源码文件做分词，语法分析就是检查源码文件是否符合 Java 语法。

2.1.2 填充符号表

符号表（Symbol Table）是一种数据结构，它由一组符号地址和符号信息组成（类似“键-值”对的形式）。

符号由抽象类 com.sun.tools.javac.code.Symbol 表示，Symbol 类有多种扩展类型的符号，比如 ClassSymbol 表示类、MethodSymbol 表示方法等。

符号表记录的信息在编译的不同阶段都要用到，如：

用于语义检查和产生中间代码；
在目标代码生成阶段，符号表是对符号名进行地址分配的依据。

这个阶段主要是根据上一步生成的抽象语法树列表完成符号填充，返回填充了类中所有符号的抽象语法树列表。

2.2 注解处理器

JDK 5 提供了注解（Annotations）支持，JDK 6 提供了“插入式注解处理器”，可以在「编译期」对代码中的特定注解进行处理，从而影响前端编译器的工作过程。

比如效率工具 Lombok 就是在这个阶段进行处理的。示例代码：

import lombok.Getter;

@Getter
public class Person {
  private String name;

  private Integer age;
}

该代码编译后：

public class Person {
    private String name;
    private Integer age;

    public Person() {
    }

    public String getName() {
        return this.name;
    }

    public Integer getAge() {
        return this.age;
    }
}

其中两个 getter 方法就是 @Getter 注解在这个阶段产生的效果（具体实现原理网上可以找到相关内容）。

2.3 语义分析与字节码生成

抽象语法树能表示一个结构正确的源程序，却无法保证语义是否符合逻辑。

而语义分析就对语法正确的源程序结合上下文进行相关性质的检查（类型检查、控制流检查等）。比如：

int a = 1;
boolean b = false;

// 这样赋值显然是错误的
// 但在语法上是没问题的，这个错误是在语义分析时检查的
int c = a + b;

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

2.3.1 标注检查

检查内容：变量使用前是否已被声明、变量与赋值之间的数据类型是否匹配等。

常量折叠

该过程中，还会进行一个常量折叠（Constant Folding）的代码优化。

比如，我们在代码中定义如下：

int a = 1 + 2;

在抽象语法树上仍能看到字面量 "1"、"2" 和操作符 "+"，但经过常量折叠优化后，在语法树上将会被标注为 "3"。

2.3.2 数据及控制流分析

主要检查内容：

局部变量使用前是否赋值
方法的每条路径是否有返回值
受检查异常是否被正确处理等

2.3.3 解语法糖

语法糖（Syntactic Sugar）：也称糖衣语法，指的是在计算机语言中添加某种语法，该语法对语言的编译结果和功能并没有实际影响，却能更方便程序猿使用该语言。 PS: 就是让我们写代码更舒服的语法，像吃了糖一样甜。

Java 中常见的语法糖有泛型、变长参数、自动装箱拆箱等。

JVM 其实并不支持这些语法，它们在编译阶段要被还原成原始的基础语法结构。该过程就称为解语法糖（打回原形）。

2.3.4 字节码生成

Javac 编译过程的最后一个阶段。主要是把前面各个步骤生成的信息转换为字节码指令写入磁盘中。

此外，编译器还进行了少量的代码添加和转换工作。比如实例构造器 <init>() 和类构造器 <clinit>() 方法就是在这个阶段被添加到语法树的。

还有一些代码替换工作，例如将字符串的 "+" 操作替换为 StringBuilder（JDK 5 及以后）或 StringBuffer（JDK 5 之前）的 append() 操作。

3. Java 语法糖

3.1 泛型

泛型这个概念大家应该都不陌生，Java 是从 5.0 开始支持泛型的。

由于历史原因，Java 使用的是“类型擦除式泛型（Type Erasure Generics）”，也就是泛型只会在源码中存在，编译后的字节码文件中，全部泛型会被替换为原先的裸类型（Raw Type）。

因此，在运行期间 List<String> 和 List<Integer> 其实是同一个类型。例如：

public class GenericTest {
  public static void main(String[] args) {
    List<Integer> l1 = new ArrayList<>();
    l1.add(1);
    List<String> l2 = new ArrayList<>();
    l2.add("2");
  }
}

经编译器擦除类型后：

public class GenericTest {
    public GenericTest() {
    }

    public static void main(String[] var0) {
        // 原先的泛型都没了
        ArrayList var1 = new ArrayList();
        var1.add(1);
        ArrayList var2 = new ArrayList();
        var2.add("2");
    }
}

类型擦除是有缺点的，比如：

由于类型擦除，会将泛型的类型转为 Object，但是 int、long 等原始数据类型无法与 Object 互转，这就导致了泛型不能支持原始数据类型。进而引起了使用包装类（Integer、Long 等）带来的拆箱、装箱问题。
运行期无法获取泛型信息。

3.2 自动装箱、拆箱与遍历

遍历代码示例

public class GenericTest {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("hello", "world");
    for (String s : list) {
      System.out.println(s);
    }
  }
}

反编译版本 1：

public class GenericTest {
    public GenericTest() {
    }

    public static void main(String[] args) {
        List<String> list = Arrays.asList("hello", "world");
        // 使用了迭代器 Iterator 遍历
        Iterator var2 = list.iterator();

        while(var2.hasNext()) {
            String s = (String)var2.next();
            System.out.println(s);
        }
    }
}

反编译版本 2：

public class GenericTest {
  public static void main(String[] args) {
    // 创建一个数组
    List<String> list = Arrays.asList(new String[] { "hello", "world" });
    for (String s : list)
      System.out.println(s); 
  }
}

不同的反编译器得出的结果可能有所不同，这里找了两个版本对比分析。

从上面两个版本的反编译结果可以看出：Arrays.asList() 方法其实创建了一个数组，而增强 for 循环实际调用了迭代器 Iterator。

自动拆装箱代码示例

public class GenericTest {
  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 GenericTest {
  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)); // t
    System.out.println((e == f)); // f
    System.out.println((c.intValue() == a.intValue() + b.intValue())); // t
    System.out.println(c.equals(Integer.valueOf(a.intValue() + b.intValue()))); // t
    System.out.println((g.longValue() == (a.intValue() + b.intValue()))); // t
    System.out.println(g.equals(Integer.valueOf(a.intValue() + b.intValue()))); // f
  }
}

可以看到，编译器对上述代码做了自动拆装箱的操作。其中值得注意的是：

包装类的 "==" 运算不遇到算术运算时，不会自动拆箱。
equals() 方法不会处理数据转型。

此外，还有个值得玩味的地方：为何 c==d 是 true、而 e==f 是 false 呢？似乎也是个考点。

这就要查看 Integer 类的 valueOf() 方法的源码了：

static final int low = -128;

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

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }
    
    private IntegerCache() {}
}

可以看到 Integer 内部使用了缓存 IntegerCache：其最小值为 -128，最大值默认是 127。因此，[-128, 127] 范围内的数字都会直接从缓存获取。

而且，该缓存的最大值是可以修改的，可以使用如下 VM 参数将其修改为 500：