一、什么是 JIT 即时编译?
JIT(Just-In-Time Compilation,即时编译) 是一种在程序运行期间执行编译的技术。它将字节码或其他中间表示转换为目标平台的本地机器代码,使 CPU 能够直接执行编译后的代码。
传统编译通常发生在程序运行之前,而 JIT 将部分编译工作推迟到运行阶段。
例如,Java 程序通常经历以下过程:
flowchart TB
A["Java 源代码"] --> B["javac 编译器"]
B --> C["JVM 字节码"]
C --> D["JVM 加载与执行"]
D --> E["解释执行"]
D --> F["JIT 编译"]
F --> G["本地机器码"]
E --> H["程序运行"]
G --> H
style A fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
需要注意,JIT 并不是所有语言运行时都必须采用的机制。有些运行时主要使用解释执行,有些采用 AOT 编译,还有一些将解释器、多个 JIT 编译层级和 AOT 编译组合使用。
1. JIT 的核心目标
JIT 的核心目标不是简单地将字节码翻译成机器码,而是:
- 降低解释开销:减少逐条解释执行字节码的成本。
- 利用运行时信息:根据真实执行行为进行针对性优化。
- 提高热点代码性能:优先编译频繁执行的方法和循环。
- 动态调整执行策略:根据运行时反馈重新编译或去优化。
- 平衡启动成本与执行效率:避免对所有代码一开始就进行高成本优化。
2. JIT 与传统编译的区别
| 对比维度 | JIT 即时编译 | AOT 提前编译 |
|---|---|---|
| 编译时间 | 程序运行期间 | 程序运行之前 |
| 编译依据 | 源代码、字节码或 IR,结合运行时信息 | 编译阶段可获得的信息 |
| 目标代码 | 通常生成本地机器码 | 通常生成本地机器码 |
| 运行时开销 | 存在编译和预热成本 | 通常无需运行时 JIT 编译 |
| 动态优化 | 可以利用运行时反馈 | 通常缺少实际运行反馈 |
| 启动性能 | 可能受到预热影响 | 通常更有利于快速启动 |
| 适用场景 | 长时间运行、热点明显的程序 | 启动敏感、部署环境受限的程序 |
AOT 并不意味着完全无法进行运行时优化。例如,AOT 程序仍然可以通过运行时分析、动态分派和其他优化机制提升性能,只是其代码生成主要发生在运行之前。
二、为什么需要 JIT?
理解 JIT,需要先理解解释执行和传统编译的局限。
1. 解释执行的性能问题
解释器通常需要读取字节码、解析操作码、获取操作数,再执行对应操作。
例如:
iload_0
iload_1
iadd
istore_2
解释器需要依次处理这些指令。
在大量循环和重复方法调用中,指令读取、分派和执行调度会产生额外开销。
flowchart TB
A["读取字节码"] --> B["解析操作码"]
B --> C["获取操作数"]
C --> D["执行指令"]
D --> E{"是否还有指令"}
E -->|"是"| A
E -->|"否"| F["执行结束"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style C fill:#FFF5DE,stroke:#E8D29A,color:#334155
style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
解释器可以采用各种优化技术降低这些开销,但对于持续执行的热点代码,直接运行优化后的本地机器码通常更有优势。
2. 传统 AOT 编译的局限
AOT 编译发生在程序运行之前。
编译器可以进行控制流分析、数据流分析、常量传播等静态优化,但无法完整获知程序未来的实际运行行为。
例如:
public int calculate(Object value) {
if (value instanceof Integer) {
return ((Integer) value) + 10;
}
return 0;
}
静态编译时,编译器需要考虑不同类型的可能性。
但如果运行时发现,这个方法在实际执行中几乎始终接收 Integer,JIT 就可以利用这一信息生成更具针对性的机器码。
这就是 JIT 的重要优势:它能够根据真实运行行为优化程序,而不是只依赖编译前的静态信息。
三、JIT 的完整工作流程
JIT 通常不是在程序启动时编译所有代码,而是通过运行时监控识别值得优化的代码。
典型流程包括:
- 程序启动,加载字节码或中间表示。
- 通过解释器或低优化级别代码执行程序。
- 收集方法调用次数、循环执行次数和类型信息。
- 判断代码是否达到热点阈值。
- 将热点代码提交给 JIT 编译器。
- 生成并安装本地机器码。
- 后续执行优先使用编译后的代码。
- 如果优化假设失效,可能触发去优化。
flowchart TB
A["程序启动"] --> B["加载字节码"]
B --> C["解释执行或基础编译"]
C --> D["收集运行时信息"]
D --> E{"是否达到编译条件"}
E -->|"否"| C
E -->|"是"| F["提交 JIT 编译"]
F --> G["中间表示优化"]
G --> H["生成本地机器码"]
H --> I["安装编译代码"]
I --> J["执行优化后的代码"]
J --> K{"优化假设是否成立"}
K -->|"是"| J
K -->|"否"| L["去优化"]
L --> C
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style D fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style I fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style J fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style K fill:#FFF5DE,stroke:#E8D29A,color:#334155
style L fill:#F3EDFC,stroke:#C4B2E3,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
以上是典型的 JIT 执行模型,不代表所有运行时都严格按照这一顺序工作。
四、热点代码检测(HotSpot Detection)
JIT 最重要的机制之一是热点检测。
热点代码(Hot Code) 是指程序运行过程中被频繁执行的代码,通常包括:
- 高频调用的方法。
- 高频执行的循环。
- 经常执行的代码路径。
- 具有较高优化收益的代码片段。
JIT 不会无差别地编译所有代码,因为编译本身也需要消耗 CPU 时间和内存。
如果一个方法只执行一次,那么为它进行高成本优化可能得不偿失。
1. 方法调用计数
运行时可以记录方法被调用的次数。
例如:
public void process() {
// 业务处理逻辑
}
如果 process() 在短时间内被大量调用,运行时可能将其识别为热点方法。
2. 循环回边计数
对于循环结构,JIT 还可以监控循环执行次数。
例如:
public long sum(int n) {
long result = 0;
for (int i = 0; i < n; i++) {
result += i;
}
return result;
}
循环可能只通过一次方法调用就执行数百万次。
如果只统计方法调用次数,就可能忽略这种热点。因此,运行时还需要关注循环回边(Loop Backedge)的执行频率。
3. 热点阈值
热点检测通常需要设置一定的触发条件。
例如:
| 监控指标 | 作用 |
|---|---|
| 方法调用次数 | 识别频繁调用的方法 |
| 循环回边次数 | 识别高频循环 |
| 执行时间 | 判断代码的实际运行成本 |
| 类型分布 | 分析对象类型和调用目标 |
| 编译收益 | 评估是否值得进行优化 |
需要注意,热点阈值不一定是固定常量。实际运行时可能结合代码执行频率、编译队列、代码复杂度和运行时策略动态调整。
4. 为什么热点检测很重要?
热点检测决定了 JIT 的编译资源分配。
flowchart TB
A["运行中的代码"] --> B["采集执行数据"]
B --> C["分析调用与循环频率"]
C --> D{"是否具有热点特征"}
D -->|"否"| E["继续解释或低级别执行"]
D -->|"是"| F["进入编译队列"]
F --> G["执行优化编译"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
热点检测的核心价值是:将有限的编译资源投入到最可能产生性能收益的代码上。
五、JIT 的编译层级
现代 JIT 不一定只有一个编译器。为了平衡编译速度和执行性能,一些运行时会采用分层编译(Tiered Compilation)。
1. 分层编译的基本思想
不同优化级别具有不同的成本:
- 低优化级别:编译速度快,但生成的机器码优化程度较低。
- 高优化级别:编译成本更高,但可能生成执行效率更好的机器码。
分层编译让运行时能够逐步提升代码的优化等级。
flowchart TB
A["程序代码"] --> B["解释执行"]
B --> C{"是否需要编译"}
C -->|"否"| B
C -->|"是"| D["基础编译"]
D --> E["收集更多运行时信息"]
E --> F{"是否值得深度优化"}
F -->|"否"| D
F -->|"是"| G["高优化级别编译"]
G --> H["优化后的机器码"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#FFF5DE,stroke:#E8D29A,color:#334155
style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
style G fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
2. 分层编译的优势
| 优势 | 说明 |
|---|---|
| 降低编译等待 | 先采用较快的执行方式 |
| 减少无效优化 | 不必对所有代码进行高成本编译 |
| 提升长期性能 | 对热点代码进行深度优化 |
| 逐步积累信息 | 利用实际执行数据指导后续编译 |
3. Java HotSpot 的分层编译
HotSpot JVM 具有成熟的分层编译机制。
典型执行层级包括:
| 层级 | 执行方式 | 主要特点 |
|---|---|---|
| Tier 0 | 解释执行 | 收集基础运行信息 |
| Tier 1 | C1 编译,简单编译 | 快速生成机器码 |
| Tier 2 | C1 编译,受限分析 | 收集更多性能分析信息 |
| Tier 3 | C1 编译,完整性能分析 | 为进一步优化积累数据 |
| Tier 4 | C2 编译 | 进行较深度的优化 |
其中:
- C1 是偏向快速编译的编译器。
- C2 是偏向高性能优化的编译器。
实际执行层级受到 JVM 版本、启动参数、运行时策略等因素影响。并非每个方法都必须经过全部层级。
六、JIT 的核心优化技术
JIT 的性能优势,很大程度上来自运行时优化。
1. 方法内联(Method Inlining)
方法内联是 JIT 最重要的优化技术之一。
它将被调用方法的代码直接嵌入调用位置,减少方法调用过程中的额外开销。
例如:
public int square(int x) {
return x * x;
}
public int calculate(int value) {
return square(value) + 1;
}
未内联时,执行过程涉及一次方法调用。
内联后,逻辑可能变为:
public int calculate(int value) {
return value * value + 1;
}
方法内联的价值不只是减少调用开销,更重要的是为后续优化创造条件。
例如:
- 常量传播。
- 死代码消除。
- 公共子表达式消除。
- 循环优化。
- 逃逸分析。
需要注意,内联并不是简单的文本替换。编译器需要考虑调用目标、方法大小、调用频率、递归关系和代码膨胀等因素。
2. 常量折叠(Constant Folding)
如果某个表达式在编译阶段能够确定结果,编译器可以提前计算。
例如:
int result = 10 * 20 + 5;
可能被优化为:
int result = 205;
这样就不需要在运行时重复执行相关计算。
3. 常量传播(Constant Propagation)
如果变量的值在某个执行路径中可以确定,编译器可以将变量替换为对应的常量。
例如:
int x = 10;
int y = x + 5;
可以优化为:
int y = 15;
常量传播和常量折叠经常配合使用。
4. 死代码消除(Dead Code Elimination)
删除不会影响程序可观察结果的计算和指令。
例如:
int a = 10;
int b = 20;
int result = a + b;
return 100;
如果 result 不会影响任何可观察行为,那么相关计算可能被删除。
需要注意,不能随意删除可能产生副作用的代码,例如文件写入、网络请求、状态修改和异常抛出等操作。
5. 逃逸分析(Escape Analysis)
逃逸分析用于判断对象的引用是否逃逸出某个分析范围。
例如:
public int calculate() {
Point point = new Point(10, 20);
return point.x + point.y;
}
如果编译器能够证明 point 不会逃逸出当前方法,并且对象的使用方式满足优化条件,就可能消除对象分配。
相关优化包括:
- 标量替换。
- 锁消除。
- 部分分配优化。
这里有一个重要区别:
逃逸分析本身不是内存分配策略,它是帮助编译器判断对象是否可以进行进一步优化的分析技术。
对象不逃逸,也不意味着一定会被分配在栈上。实际优化可能是完全消除对象分配,或者将对象拆解为独立字段。
6. 锁消除(Lock Elimination)
如果 JIT 能够证明某个对象不会被其他线程访问,那么围绕该对象的同步操作可能是冗余的。
例如:
public void process() {
Object lock = new Object();
synchronized (lock) {
// 执行操作
}
}
如果 lock 不会逃逸,JIT 可能消除相关同步操作。
锁消除依赖逃逸分析等信息,并不意味着程序中的所有同步操作都可以被删除。
7. 循环优化(Loop Optimization)
循环通常是程序中的热点区域。
JIT 可以对循环进行多种优化:
| 优化技术 | 作用 |
|---|---|
| 循环展开 | 减少循环控制和分支开销 |
| 循环不变代码外提 | 将循环内不变的计算移到循环外 |
| 强度削弱 | 用成本更低的运算替代昂贵运算 |
| 循环向量化 | 利用 SIMD 指令并行处理多个数据 |
| 范围检查消除 | 在证明安全时减少数组边界检查 |
例如:
for (int i = 0; i < array.length; i++) {
result += array[i] * factor;
}
如果 factor 在循环过程中不发生变化,编译器可能将相关计算或访问检查进行优化。