JVM系列8-前端编译与优化

简介: JVM系列8-前端编译与优化

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. 填充符号表:产生符号地址和符号信息
  1. 插入式注解处理器的注解处理过程
  2. 分析与字节码生成过程
  1. 标注检查:对语法的静态信息进行检查
  2. 数据流及控制流分析:对程序的动态运行过程进行检查
  3. 解语法糖:将简化代码编写的语法糖还原为原来的样子
  4. 字节码生成:将前面各个步骤所生成的信息转化为字节码

我们可以把上述处理过程对应到代码中, Javac编译动作的入口是 com.sun.tools.javac.main.JavaCompiler类, 上述3个过程的代码逻辑集中在这个类的compile()和compile2() 方法里, 其中主体代码如下图所示, 整个编译过程主要的处理由图中标注的8个方法来完成

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):也称糖衣语法,指的是在计算机语言中添加某种语法,该语法对语言的编译结果和功能并没有实际影响,却能更方便程序猿使用该语言。

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");    
  }
}

类型擦除是有缺点的,比如:

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

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  
  }
}

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

  1. 包装类的 "==" 运算不遇到算术运算时,不会自动拆箱。
  2. 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:

-XX:AutoBoxCacheMax=500复制代码

增加该参数后,上述 e==f 也是 true 了。


目录
相关文章
|
11天前
|
缓存 安全 算法
Java面试题:如何通过JVM参数调整GC行为以优化应用性能?如何使用synchronized和volatile关键字解决并发问题?如何使用ConcurrentHashMap实现线程安全的缓存?
Java面试题:如何通过JVM参数调整GC行为以优化应用性能?如何使用synchronized和volatile关键字解决并发问题?如何使用ConcurrentHashMap实现线程安全的缓存?
11 0
|
1天前
|
前端开发 JavaScript UED
优化前端性能:提升网页加载速度的关键技巧
在当今互联网时代,网页加载速度直接影响用户体验和SEO排名。本文深入探讨了优化前端性能的关键技巧,包括减少HTTP请求、压缩和合并文件、优化图片和CSS,以及使用CDN加速等策略,帮助开发者有效提升网页加载速度,提升用户满意度和网站效能。
|
9天前
|
缓存 前端开发 JavaScript
前端性能优化都有那些方案 ?
【7月更文挑战第11天】 前端性能优化包括资源合并压缩、懒加载、CDN使用、代码优化、缓存利用和图片优化等策略。例如,减少HTTP请求、压缩CSS/JS、事件委托、利用浏览器及服务器缓存、选择合适图片格式等,旨在提升网页速度和用户体验。服务工作者、异步加载和响应式设计也是关键。持续学习新技术以适应不断变化的优化需求。
20 1
|
10天前
|
缓存 Prometheus 监控
Java面试题:如何监控和优化JVM的内存使用?详细讲解内存调优的几种方法
Java面试题:如何监控和优化JVM的内存使用?详细讲解内存调优的几种方法
30 3
|
14天前
|
前端开发 JavaScript 开发工具
使用RequireJS和Bower优化前端资源管理和模块化开发
【7月更文挑战第7天】随着Web应用的复杂度日益增长,前端资源管理和模块化开发变得尤为重要。RequireJS和Bower是两个流行的前端开发工具,它们分别解决了JavaScript模块化加载和前端包依赖管理的问题,极大地提升了开发效率和代码质量。
17 3
|
21天前
|
Web App开发 缓存 前端开发
前端性能优化技巧与工具
【6月更文挑战第30天】前端性能优化旨在提升Web应用速度和响应性,关乎用户体验、转化率及SEO。关键技巧包括减少HTTP请求、压缩资源、利用缓存、异步加载和优化DOM操作。工具如Lighthouse、PageSpeed Insights、Webpack Bundle Analyzer及Chrome DevTools提供性能分析和优化建议。优化是持续的过程,适应复杂Web需求。
|
23天前
|
敏捷开发 缓存 前端开发
阿里云云效产品使用问题之流水线构建前端项目比较慢。该如何优化
云效作为一款全面覆盖研发全生命周期管理的云端效能平台,致力于帮助企业实现高效协同、敏捷研发和持续交付。本合集收集整理了用户在使用云效过程中遇到的常见问题,问题涉及项目创建与管理、需求规划与迭代、代码托管与版本控制、自动化测试、持续集成与发布等方面。
|
23天前
|
Java 编译器
Java健壮性 Java可移植性 JDK, JRE, JVM三者关系 Java的加载与执行原理 javac编译与JAVA_HOME环境变量介绍 Java中的注释与缩进 main方法的args参数
Java健壮性 Java可移植性 JDK, JRE, JVM三者关系 Java的加载与执行原理 javac编译与JAVA_HOME环境变量介绍 Java中的注释与缩进 main方法的args参数
20 1
|
7天前
|
编解码 缓存 前端开发
现代前端开发中的响应式设计实践与优化
在当今快节奏的互联网环境中,用户对网页的访问设备多样化,响应式设计成为前端开发中不可或缺的一环。本文探讨了响应式设计的重要性以及实现中的最佳实践,涵盖了基本概念、布局策略、以及性能优化的关键技术,为开发人员提供了全面的指导与思路。
|
11天前
|
存储 设计模式 监控
Java面试题:简述JVM的内存结构,包括堆、栈、方法区等。栈内存优化的方法有 哪些?
Java面试题:简述JVM的内存结构,包括堆、栈、方法区等。栈内存优化的方法有 哪些?
17 0