跳到主要内容

运行时环境

运行时环境​

编译器把源代码翻译成目标代码只完成了一半工作,另一半是安排好程序运行时怎么用内存、怎么调用函数、怎么管理数据的生命周期。这一整套约定和机制统称为运行时环境(Runtime Environment)。它由编译器、操作系统和硬件共同支撑,程序员平时看不到,但一旦崩栈、内存泄漏或指针乱飞,问题就都在这里。

通俗理解:运行时环境就像餐厅后厨。菜单(源代码)翻译成菜品(目标代码)之后,还得有货架(静态区)、临时案板(栈)、冷藏库(堆)、洗碗机(GC),以及"点单-出菜"的流程约定(调用约定)。这些看不见的组织方式决定了这家店能不能开门营业。

内存布局​

一个典型进程的虚拟地址空间由低到高大致分为四块:

  • 代码段(.text):编译后的机器指令,只读。
  • 静态数据段(.data / .bss):全局变量、静态变量。.data 有初值,.bss 是零初始化。
  • 堆(Heap):动态分配的内存,malloc / new 从这里拿。向上(高地址)增长。
  • 栈(Stack):函数调用产生的活动记录,向下(低地址)增长。

堆和栈之间留着一大片空隙。之所以一个朝上、一个朝下,是为了让两者共享中间的自由空间:不管栈用得多还是堆用得多,只要总量没超,就都能扩展;两头相遇时才真正 OOM。这个设计早在 PDP-11 就定下来,一直沿用到今天。

活动记录(栈帧)​

每次函数被调用,都会在栈上分配一块空间存放它的"运行现场",叫活动记录(Activation Record)或栈帧(Stack Frame)。一个典型栈帧从高地址到低地址大约包含:

┌────────────────────┐  高地址
│ 实参(caller 传入)│
├────────────────────┤
│ 返回地址 │ ← call 指令压入
├────────────────────┤
│ 旧的帧指针(动态链)│ ← 指向 caller 的栈帧
├────────────────────┤
│ 静态链(access link)│ ← 词法外层的栈帧(可选)
├────────────────────┤
│ 保存的寄存器 │
├────────────────────┤
│ 局部变量 │
├────────────────────┤
│ 为下一次调用预留空间│
└────────────────────┘ 低地址(栈顶 sp)

调用发生时:call 指令压入返回地址 → 被调函数保存旧的 rbp(或 ARM 上的 fp)→ 让 rbp = rsp → 通过 sub rsp, N 一次性开出局部变量空间。返回时反向执行:恢复 rsp、弹出旧 rbp、ret 跳回。整个过程只是几条指令,栈帧的创建和销毁几乎零成本,这也是"栈上分配"比堆快得多的根本原因。

作用域与访问外层变量​

**静态作用域(词法作用域)**由变量在源代码里的位置决定,C、Java、Python 都是这种。动态作用域则由调用链决定,Lisp 早期方言和一些 shell 用它——同名变量取"最近一次被调用者赋的值",容易写得乱。

嵌套过程(Pascal、Scheme)里,内层函数访问外层局部变量有两种典型实现:

  • 静态链(access link):每个栈帧存一个指针,指向词法上外层过程的最近一次栈帧。访问外层变量时沿静态链跳几次。层数越深,跳得越多。
  • Display 表:维护一个数组 display[0..n],display[k] 直接指向嵌套深度为 k 的当前活动记录。访问变量时一次数组下标就到位,代价是进入/离开过程时要维护这张表。

C 因为没有嵌套函数,二者都用不上;闭包语言(Scheme、JavaScript)则用"环境指针 + 捕获变量装箱"来解决类似问题。

参数传递方式​

  • 值传递(call-by-value):把实参的值拷贝一份给形参。C、Java 都是纯值传递(Java 对象传的是引用的值,容易被误认为引用传递)。
  • 引用传递(call-by-reference):形参是实参的别名,改形参就是改实参。C++ 的 T&、C# 的 ref、Fortran 的默认方式。
  • 名传递(call-by-name):把实参当作一段"未求值的表达式"传进去,每次用到才求值。Algol 60 的招牌特性,Haskell 的惰性求值是它的现代亲戚。
  • 值-结果传递(call-by-value-result / copy-in copy-out):进入时拷贝进去、返回时再拷贝出来。Ada 的 in out 参数、Fortran 某些实现用它,别名问题比引用传递少但成本更高。

调用约定​

**调用约定(Calling Convention)**规定谁把参数放哪、谁负责清栈、哪些寄存器由调用者保存、哪些由被调用者保存。常见的几种:

  • cdecl(x86 Linux/Win 默认 C 调用):参数从右向左压栈,调用者清栈,因此支持 printf 这种变参函数。
  • stdcall(Win32 API):参数从右向左压栈,被调用者清栈,函数签名一固定就不能变参。
  • System V AMD64(Linux/macOS 64 位):前 6 个整型参数走寄存器 rdi, rsi, rdx, rcx, r8, r9,浮点走 xmm0-7,剩下的才压栈。
  • Windows x64:前 4 个参数走 rcx, rdx, r8, r9,调用者要额外留 32 字节"影子空间"给被调用者做寄存器备份。

寄存器分caller-saved(调用前调用者自己保存,如 x86-64 的 rax, rcx, rdx)和callee-saved(被调用函数负责保存和恢复,如 rbx, rbp, r12-r15)。约定不一致就会崩栈或返回值错乱,跨语言调用(如 C 调 Rust)时特别要小心。

堆管理​

堆不像栈那样先进后出,分配和释放顺序完全自由,所以需要一套显式的分配器。经典 malloc 策略有:

  • 首次适配(First Fit):从空闲链表头开始找,遇到第一块够大的就切一块出来。快,但小碎片容易堆积在链表前段。
  • 最佳适配(Best Fit):遍历整个空闲链表,选最"贴合"的那块。碎片少但每次都要扫全表。
  • 伙伴系统(Buddy System):把堆按 2 的幂切分,分配时找不小于请求的最小块,释放时合并同大小的"伙伴"。速度快、合并简单,Linux 内核物理页分配器就是它。

无论哪种策略都会产生外部碎片(空闲块加起来够大但不连续)和内部碎片(分配的块比请求的略大)。现代分配器(glibc 的 ptmalloc、tcmalloc、jemalloc)会分尺寸类、按线程本地缓存来同时优化速度和碎片。

垃圾回收​

手动 free 心智负担大,于是有了自动垃圾回收(GC):

  • 引用计数:每个对象记住有多少引用指向它,归零就回收。实现简单、回收及时(Python、Swift 用它),但处理不了循环引用——两个对象互引用会永远留着,需要额外的循环检测器补救。
  • 标记-清除(Mark-Sweep):从根集合(栈、全局变量、寄存器)出发,可达的对象全部标记,剩下的清扫回收。能处理循环引用,但会造成堆碎片。
  • 复制式(Copying):把堆分成两半,只用一半;GC 时把活对象复制到另一半,然后整体丢弃原半区。天然规整、没有碎片,代价是浪费一半空间。
  • 分代式(Generational):基于弱分代假设——绝大多数对象很快就死。堆分成新生代和老年代,新生代高频用复制式(对象少、复制便宜),老年代低频用标记-清除或标记-整理。JVM、V8、.NET CLR 都是这套思路。

一次函数调用的栈帧变化​

以 main 调 foo(1, 2)、foo 再调 bar(3) 为例,栈顶变化大致是:

初始:            调 foo 后:            调 bar 后:           bar 返回后:
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ main 帧 │ │ main 帧 │ │ main 帧 │ │ main 帧 │
│ x,y │ │ x,y │ │ x,y │ │ x,y │
└──────────┘ ├──────────┤ ├──────────┤ ├──────────┤
│ 参数 1,2 │ │ 参数 1,2 │ │ 参数 1,2 │
│ 返回地址 │ │ 返回地址 │ │ 返回地址 │
│ foo 帧 │ │ foo 帧 │ │ foo 帧 │
│ 局部 a │ │ 局部 a │ │ 局部 a │
└──────────┘ ├──────────┤ └──────────┘
│ 参数 3 │
│ 返回地址 │
│ bar 帧 │
└──────────┘

栈帧像积木一样叠上来,函数返回时最上面那块整齐地弹掉,控制流沿返回地址回到 caller 的下一条指令。这套机制是几乎所有过程式语言运行时的骨架,理解它就能看懂大部分崩溃现场(stack overflow、smash the stack、栈回溯)到底发生了什么。