一、程序为什么需要编译或解释?
程序员使用编程语言描述计算逻辑,但不同编程语言的语法和语义,并不是 CPU 能够直接理解的指令格式。
CPU 执行的是符合其指令集架构(ISA)的机器指令。因此,程序必须通过某种执行机制,将源代码所描述的操作转化为处理器能够完成的计算。
常见的程序执行机制包括:
- 编译(Compilation):将源代码或中间表示转换为另一种代码形式,常见结果包括机器代码和字节码。
- 解释(Interpretation):由解释器读取程序表示,并按照语言语义执行相应操作。
- 即时编译(JIT):程序运行期间,将部分代码动态编译为机器代码。
- 提前编译(AOT):在程序运行之前完成编译,提前生成目标平台的代码。
需要注意,编译与解释并不是互斥的语言属性。现代语言运行时经常结合多种技术完成程序执行。
二、编译(Compilation)
2.1 什么是编译?
编译是将一种程序表示转换为另一种程序表示的过程。
最常见的情况是将高级语言源代码转换为目标平台的机器代码。
例如,C 语言程序:
#include <stdio.h>
int main(void) {
int a = 10;
int b = 20;
printf("%d\n", a + b);
return 0;
}
通过 GCC 编译:
gcc main.c -o app
编译器会分析源代码,并生成目标平台能够执行的程序。
从逻辑上看:
flowchart TB
A["源代码"] --> B["词法分析"]
B --> C["语法分析"]
C --> D["语义分析"]
D --> E["中间表示 IR"]
E --> F["代码优化"]
F --> G["目标代码生成"]
G --> H["机器代码或目标文件"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
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.2 编译器的主要工作阶段
1. 词法分析(Lexical Analysis)
将源代码字符序列转换为具有语法意义的词法单元(Token)。
例如:
int result = 10 + 20;
可以识别出:
| Token | 类型 |
|---|---|
int |
关键字 |
result |
标识符 |
= |
运算符 |
10 |
整数常量 |
+ |
运算符 |
20 |
整数常量 |
; |
分隔符 |
词法分析主要负责识别语言中的基本符号,不负责完整判断表达式是否合法。
2. 语法分析(Syntax Analysis)
根据语言的语法规则,将 Token 组织成语法结构。
例如:
int result = 10 + 20;
可以构建类似下面的抽象语法树(AST):
VariableDeclaration
├── Type: int
├── Name: result
└── Initializer
└── Addition
├── IntegerLiteral: 10
└── IntegerLiteral: 20
语法分析主要判断代码结构是否符合语言语法。
例如:
int = result 10;
不符合 C 语言变量声明的语法规则。
3. 语义分析(Semantic Analysis)
语法正确不代表程序在语义上合法。
语义分析需要进一步检查:
- 变量是否声明。
- 类型是否匹配。
- 函数调用参数是否符合要求。
- 作用域规则是否满足。
- 表达式是否符合语言语义。
例如:
int number = "hello";
语法结构基本合法,但字符串字面量不能直接赋值给 C 语言的 int 类型变量,因此会产生类型诊断。
4. 中间表示(Intermediate Representation,IR)
编译器通常不会直接从 AST 生成最终机器代码,而是先转换成一种便于分析和优化的中间表示。
例如,LLVM IR 可以用类似下面的形式表达简单计算:
define i32 @add() {
entry:
%result = add i32 10, 20
ret i32 %result
}
IR 可以降低源语言与目标处理器之间的耦合。
编译器可以针对同一种 IR 实现不同的优化策略和目标代码生成器。
5. 代码优化(Code Optimization)
编译器会在保证程序语义不变的前提下,对程序进行优化。
常见优化包括:
| 优化技术 | 作用 |
|---|---|
| 常量折叠 | 编译期计算常量表达式 |
| 常量传播 | 将已知常量传播到其他表达式 |
| 死代码消除 | 删除不会影响程序结果的代码 |
| 公共子表达式消除 | 避免重复计算相同表达式 |
| 循环优化 | 减少循环中的重复开销 |
| 内联优化 | 将函数调用替换为函数体代码 |
| 寄存器分配 | 尽可能使用 CPU 寄存器保存变量 |
例如:
int result = 10 * 20 + 5;
编译器可能直接计算出:
int result = 205;
这就是常量折叠。
6. 目标代码生成(Code Generation)
将优化后的中间表示转换为目标平台的指令。
生成结果可能是:
- 汇编代码。
- 机器代码。
- 目标文件。
- 其他平台相关代码表示。
最终结果取决于编译器和构建配置。
2.3 编译的特点
- 通常在程序运行之前完成主要代码转换。
- 可以进行较深入的静态分析和优化。
- 可以提前发现部分语法、类型和语义错误。
- 可以生成针对特定 CPU 架构的机器代码。
- 编译结果可能依赖操作系统、指令集和运行库。
编译并不意味着程序一定是独立可执行文件。生成的程序仍可能依赖动态库、运行时环境和操作系统服务。
三、解释(Interpretation)
3.1 什么是解释?
解释是由解释器根据程序的语法和语义,在运行时执行程序所描述操作的一种机制。
与传统的原生编译方式不同,解释执行不一定需要提前生成独立的机器代码文件。
例如,Python 程序:
a = 10
b = 20
result = a + b
print(result)
可以通过 CPython 解释器运行:
python main.py
解释器负责读取程序、执行相应操作,并输出结果。
3.2 解释器如何工作?
解释器的具体实现取决于语言和运行时。
常见解释器可以采用以下执行模型:
flowchart TB
A["源代码"] --> B["词法分析与语法分析"]
B --> C["构建语法结构"]
C --> D["解释器读取程序表示"]
D --> E["执行对应操作"]
E --> F["更新运行时状态"]
F --> G{"是否还有待执行操作"}
G -->|"是"| D
G -->|"否"| H["程序结束"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style G fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
需要强调:这是一种抽象的解释执行模型,并不是所有解释器都直接逐行读取源代码。
例如,CPython 通常先将 Python 源代码编译为字节码,再由虚拟机执行字节码。
3.3 解释器的主要组成
1. 源代码解析器
负责识别源代码结构,并构建 AST 或其他内部表示。
2. 执行引擎
根据程序表示执行对应操作。
例如:
result = 10 + 20
解释器需要完成:
- 读取常量。
- 执行加法操作。
- 创建或更新变量绑定。
- 保存执行结果。
3. 运行时环境(Runtime Environment)
解释执行通常需要运行时环境提供基础能力,例如:
- 变量与作用域管理。
- 函数调用与返回。
- 对象创建与访问。
- 异常处理。
- 内存管理。
- 模块加载。
4. 内置函数与运行库
解释器通常还会提供标准库、内置函数以及与操作系统交互的能力。
3.4 解释执行的特点
- 可以在运行时处理程序表示。
- 通常依赖解释器或虚拟机。
- 便于动态类型检查和运行时行为管理。
- 通常具有较好的跨平台部署能力。
- 可能存在解释器调度和动态执行开销。
但解释执行不一定比编译执行慢。现代解释器可以采用缓存、字节码优化、JIT 等技术显著提升性能。
四、编译与解释的核心区别
编译与解释的本质区别,不是一个生成机器代码、另一个完全不生成机器代码,而是程序代码转换与执行发生的时机和方式不同。
4.1 核心对比
| 对比维度 | 编译 | 解释 |
|---|---|---|
| 核心机制 | 提前转换程序表示 | 运行时执行程序表示 |
| 代码转换时机 | 通常在运行前 | 通常在运行期间 |
| 典型产物 | 机器代码、目标文件、字节码 | AST、字节码或其他内部表示 |
| 执行依赖 | 可执行代码及运行环境 | 解释器或虚拟机 |
| 静态优化 | 通常较丰富 | 取决于解释器实现 |
| 错误发现 | 可提前发现部分错误 | 部分错误在运行时暴露 |
| 部署方式 | 可能需要目标平台产物 | 通常需要对应运行时 |
| 典型实现 | GCC、Clang | 传统 AST 解释器 |
4.2 执行性能差异
传统解释执行通常需要解释器参与指令调度和运行时操作。
例如,执行一条字节码时,解释器可能需要:
- 读取当前字节码。
- 解析操作类型。
- 获取操作数。
- 调用对应执行逻辑。
- 更新虚拟机状态。
原生机器代码则可以由 CPU 直接执行,不需要每条指令都经过高级语言解释器的调度。
不过,性能不能简单理解为编译一定快、解释一定慢。
现代运行时还会采用:
- 字节码优化。
- 内联缓存。
- 类型反馈。
- JIT 编译。
- 运行时去优化。
- 垃圾回收优化。
这些技术会显著改变实际性能表现。
4.3 编译与解释的执行模型
flowchart TB
A["源代码"] --> B{"执行模型"}
B -->|"传统编译"| C["编译器"]
C --> D["原生机器代码"]
D --> E["CPU 执行"]
B -->|"解释执行"| F["解释器"]
F --> G["程序表示"]
G --> H["解释执行引擎"]
B -->|"虚拟机执行"| I["编译为字节码"]
I --> J["虚拟机"]
J --> K["解释执行或 JIT 编译"]
K --> L["CPU 执行机器代码"]
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:#E0F0FE,stroke:#93BCE8,color:#1E4976
style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style H fill:#FFF5DE,stroke:#E8D29A,color:#334155
style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style J fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style K fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style L fill:#FFF5DE,stroke:#E8D29A,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
五、JIT 即时编译
5.1 什么是 JIT?
JIT(Just-In-Time Compilation)是即时编译技术。
它在程序运行期间,根据当前执行情况,将部分程序代码动态编译为机器代码。
JIT 结合了编译和解释的特点:
- 通过解释执行降低初始编译成本。
- 通过运行时数据收集程序执行信息。
- 将频繁执行的代码编译为机器代码。
- 利用运行时信息进行针对性优化。
JIT 是现代虚拟机和动态语言运行时的重要技术。
5.2 为什么需要 JIT?
解释器可以快速启动并开始执行程序,但对于频繁执行的代码,反复进行解释器调度可能产生较高开销。
JIT 的核心思路是:
不必一开始就将所有代码编译为机器代码,而是优先优化真正频繁执行的代码。
例如,一个循环执行一百万次的函数:
function calculate(value) {
return value * 2 + 1;
}
for (let i = 0; i < 1000000; i++) {
calculate(i);
}
运行时可以观察函数的调用频率和参数类型。
如果某段代码持续成为热点,JIT 就可能将它编译为优化后的机器代码。
5.3 JIT 的典型工作过程
flowchart TB
A["程序启动"] --> B["解释执行或低成本执行"]
B --> C["收集运行时信息"]
C --> D["识别热点代码"]
D --> E{"是否达到编译条件"}
E -->|"否"| B
E -->|"是"| F["JIT 编译"]
F --> G["生成优化机器代码"]
G --> H["执行优化后的代码"]
H --> I{"优化假设是否仍成立"}
I -->|"是"| H
I -->|"否"| J["去优化 Deoptimization"]
J --> B
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style I fill:#FFF5DE,stroke:#E8D29A,color:#334155
style J fill:#F3EDFC,stroke:#C4B2E3,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
5.4 热点代码(Hot Code)
热点代码是运行过程中被频繁执行的代码区域。
常见识别依据包括:
- 函数调用次数。
- 循环回边执行次数。
- 方法调用频率。
- 运行时性能统计。
JIT 不一定只编译整个函数,也可以根据实现策略编译特定代码区域。
5.5 类型反馈(Type Feedback)
动态语言在运行时才确定某些变量的实际类型。
例如:
function add(a, b) {
return a + b;
}
这个函数既可能接收数字,也可能接收字符串。
add(10, 20);
add("hello", "world");
JIT 可以收集函数实际接收的参数类型。
如果长期观察到参数都是数字,就可能针对数字运算生成优化代码。
但如果后来出现字符串参数,之前的优化假设可能不再成立。
此时运行时可能进行去优化(Deoptimization),恢复到更通用的执行路径。
5.6 JIT 的优化与代价
JIT 的主要优势:
- 利用运行时信息优化代码。
- 可以减少解释执行开销。
- 能针对实际运行环境生成机器代码。
- 可以根据热点动态调整优化策略。
JIT 的代价:
- 增加运行时编译开销。
- 需要管理生成的机器代码。
- 增加运行时实现复杂度。
- 可能出现去优化和重新编译。
- 程序启动阶段可能尚未获得优化收益。
因此,JIT 不一定能让所有程序都变快。对于短生命周期程序,编译成本可能无法被后续性能收益抵消。
六、AOT 提前编译
6.1 什么是 AOT?
AOT(Ahead-Of-Time Compilation)是提前编译技术。
它在程序运行之前完成代码转换,通常直接生成目标平台的机器代码,也可以生成其他形式的预编译产物。
例如:
gcc main.c -o app
GCC 会在运行程序之前完成编译和链接。
这属于典型的 AOT 编译流程。
6.2 AOT 与 JIT 的区别
| 对比维度 | AOT | JIT |
|---|---|---|
| 编译时机 | 程序运行之前 | 程序运行期间 |
| 编译依据 | 编译期可获得的信息 | 编译期与运行时信息 |
| 启动成本 | 通常较低 | 可能包含运行时编译成本 |
| 运行时优化 | 主要依赖提前完成的优化 | 可以利用运行时信息优化 |
| 代码生成 | 通常提前生成 | 运行期间动态生成 |
| 典型场景 | 原生程序、预编译应用 | JVM、JavaScript 引擎 |
AOT 与 JIT 并不是完全对立的技术。
某些运行时可以先使用 AOT 生成基础代码,再使用 JIT 对热点代码进行进一步优化。
七、不同编程语言的执行机制
理解编译、解释、JIT 和 AOT,需要结合具体语言实现来看。
7.1 C / C++
C 和 C++ 通常采用 AOT 原生编译模型。
flowchart TB
A["C / C++ 源代码"] --> B["编译器"]
B --> C["目标文件"]
C --> D["链接器"]
D --> E["原生可执行文件"]
E --> F["操作系统装载"]
F --> G["CPU 执行机器代码"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
主要特点:
- 编译阶段通常生成原生机器代码。
- 运行时不需要高级语言解释器逐条解释源代码。
- 可以进行较深入的静态优化。
- 仍可能依赖操作系统、运行库和动态链接库。