返回专栏
· 15 分钟阅读

JIT 即时编译(Just-In-Time Compilation)


一、什么是 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 通常不是在程序启动时编译所有代码,而是通过运行时监控识别值得优化的代码。

典型流程包括:

  1. 程序启动,加载字节码或中间表示。
  2. 通过解释器或低优化级别代码执行程序。
  3. 收集方法调用次数、循环执行次数和类型信息。
  4. 判断代码是否达到热点阈值。
  5. 将热点代码提交给 JIT 编译器。
  6. 生成并安装本地机器码。
  7. 后续执行优先使用编译后的代码。
  8. 如果优化假设失效,可能触发去优化。
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 在循环过程中不发生变化,编译器可能将相关计算或访问检查进行优化。