返回专栏
· 17 分钟阅读

编译、解释与执行


一、程序为什么需要编译或解释?

程序员使用编程语言描述计算逻辑,但不同编程语言的语法和语义,并不是 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 执行性能差异

传统解释执行通常需要解释器参与指令调度和运行时操作。

例如,执行一条字节码时,解释器可能需要:

  1. 读取当前字节码。
  2. 解析操作类型。
  3. 获取操作数。
  4. 调用对应执行逻辑。
  5. 更新虚拟机状态。

原生机器代码则可以由 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

主要特点:

  • 编译阶段通常生成原生机器代码。
  • 运行时不需要高级语言解释器逐条解释源代码。
  • 可以进行较深入的静态优化。
  • 仍可能依赖操作系统、运行库和动态链接库。