学习笔记19 10 月, 2026· 约 13 分钟

内存与 GC

内存与 GC 一、内存布局:线程栈、进程堆与内存碎片 托管堆的标记 压缩原理见本文《GC 垃圾回收原理与优化》。 1. 内存基础(栈、堆) 1. 线程栈(栈内存) 每个线程创建时操作系统分配一块固定大小虚拟地址空间,是线程私有临时内存。 存放:函数局部变量、函数参数、返回地址、寄存器现场;函数调用生成栈帧,函数返回直接


内存与 GC

一、内存布局:线程栈、进程堆与内存碎片

托管堆的标记-压缩原理见本文《GC 垃圾回收原理与优化》。

1. 内存基础(栈、堆)

  1. 线程栈(栈内存)
  • 每个线程创建时操作系统分配一块固定大小虚拟地址空间,是线程私有临时内存。
  • 存放:函数局部变量、函数参数、返回地址、寄存器现场;函数调用生成栈帧,函数返回直接弹出栈帧,自动回收,LIFO后进先出。
  • 优点:分配释放极快,只移动栈指针,无系统调用;不会产生外部碎片,仅对齐padding带来少量内部碎片。
  • 缺点:大小固定,不能动态扩容;局部大数组直接StackOverflow;不能返回栈上变量的指针/引用(栈帧销毁后野内存)。
  • 注意:Obj* ptr中,ptr本身存栈,ptr指向的对象实例存堆。
  1. 进程堆(堆内存)
  • 整个进程共享,由分配器管理(系统malloc或引擎自定义分配器),手动/GC管理生命周期。
  • new/malloc从堆分配,free/delete释放;会产生外部碎片(空闲被存活对象分割成不连续空洞)、内部碎片(对齐、桶大小向上取整)。
  • C++硬限制:原生裸指针,运行时不能移动堆上对象,一旦移动所有裸指针直接野指针崩溃。
  1. 内存碎片概念
  • 内部碎片:分配的内存比实际需要大,多出部分浪费。
  • 外部碎片:总空闲内存充足,但都是零散不连续块,无法满足大块内存申请。
  • C++没有运行时堆压缩能力;.NET GC可以做标记‑压缩,运行时移动对象。

2. UE引擎如何应对C++内存碎片(不能运行时压缩)

UE的UObject GC是标记清扫,不压缩、不移动对象。缓解碎片手段:

  1. 自研FMallocBinned分桶分配器:按固定尺寸桶管理内存,相同大小块复用,抑制外部碎片,代价内部碎片。
  2. 多独立内存池隔离:游戏对象、渲染、物理、音频各自独立内存池,碎片不会互相污染。
  3. 对象池、预分配、批量释放:避免频繁new/delete;关卡卸载批量释放一大片内存。
  4. 仅在加载黑屏(天然STW窗口),部分独立内存池做对象拷贝整理;游戏运行时绝不移动对象。
  5. TObjectPtr:只是安全弱指针,不能支持对象搬迁重定向。
  6. 兜底:TrimMemory归还空闲内存给OS;碎片过高主动重新加载关卡。

3. 补充与易错点

  • 栈溢出无法捕获:.NET 的 StackOverflowException 不能被 try-catch 捕获,进程直接终止。深递归必须在逻辑上设终止条件,不能指望兜底。
  • 栈大小是固定的:Windows 默认每线程约 1MB、Linux 约 8MB;Unity 主线程的栈大小可在 Player Settings 里调整,托管线程也可在构造时传入 maxStackSize。栈上开大数组是最常见的崩溃原因。
  • 栈帧大小编译期确定:局部变量越多、越大,栈帧越大,与"运行时按需分配"无关。
  • 碎片在 Unity 里更严重:Unity 的 Boehm GC 不压缩堆(见本文《GC 垃圾回收原理与优化》),托管堆碎片一旦形成就无法通过搬移消除,只能靠减少大块分配、对象池缓解。
  • C++ 侧同样不能压缩:原生裸指针假设对象地址不变,任何搬移都会让所有裸指针失效,所以 UE 只能靠分桶分配器、独立内存池、加载期整理来间接缓解。
  • 内部碎片 vs 外部碎片的判据:浪费发生在"已分配块内部"是内部碎片;发生在"空闲块之间无法拼成大块"是外部碎片。

二、GC 垃圾回收原理与优化

1. GC 是什么

GC 是托管堆上的自动内存管理器,负责回收没有任何引用指向的 class 对象。

  • 值类型(struct、int、Vector3)分配在栈或结构体缓冲区里,不在托管堆,不受 GC 管理。
  • 只要引用链可达,对象就不会被回收;所有指向它的引用全部消失,才被判定为垃圾。

2. 回收原理:可达性标记

  1. 根(Root):存活引用的起点,包括局部变量、静态变量(static)、寄存器、场景中激活的物体。
  2. Mark 标记:从所有根出发遍历引用图,可达对象标记为存活,不可达即为垃圾。
  3. Sweep 清除:回收未被标记的对象。只释放、不移动,因此堆上会留下空洞,即内存碎片。
  4. Compact 压缩:把存活对象搬到堆的一端,挤掉空洞,尾部合并成一块连续空闲内存,消除外部碎片。压缩阶段会 Stop-The-World(STW),暂停所有业务线程,表现为掉帧卡顿。

压缩之后还能找得到对象:重定位

.NET 的标记-压缩分三步:标记 Mark → 拷贝压缩 Compact → 重定位 Relocate。

重定位能成立的前提是:GC 能识别内存中所有托管引用。压缩时记录"旧地址 → 新地址"的转发表,再把所有引用批量改成新地址。

这也是 C++ 做不到运行时堆压缩的根本原因:C++ 分不清一段内存里哪些数字是指针、哪些是普通数值,无法自动更新指针。

3. 三种基本策略:清除、压缩、复制

方式 做法 效果
标记-清除 只释放垃圾,不移动对象 快,但不解决外部碎片
标记-压缩 移动存活对象,消除碎片 解决碎片,但要 STW,代价高
标记-复制(Copying GC) 把存活对象复制到 To 空间 Java 新生代常用

CoreCLR(标准 .NET)的实际策略:

  • 小对象堆(SOH,包含 Gen0 / Gen1 / Gen2)回收时默认压缩,把存活对象搬移压实;
  • 大对象堆(LOH)默认不压缩,因为拷贝成本极高(.NET Core 3.0+ 可用 GCSettings.LargeObjectHeapCompactionMode 要求压缩一次);
  • 后台 GC(Background GC)允许 Gen2 回收期间继续分配,减少 STW 时长。

⚠️ 这只是 .NET 的模型。Unity 用的不是这套 GC,见下一节。

4. 关键前提:Unity 的 GC 不是 .NET GC

Unity 的 Mono 和 IL2CPP 运行时用的都是 Boehm–Demers–Weiser GC(Boehm GC),特性与 .NET 完全不同:

维度 .NET CoreCLR GC Unity 的 Boehm GC
是否分代 分 0 / 1 / 2 代 不分代,每次回收全堆扫描
是否压缩 SOH 压缩、LOH 不压缩 不压缩,对象地址终身不变
扫描方式 精确式,知道每个引用的类型 保守式,把内存中疑似指针的字都当引用
触发条件 分配量触达各代预算 累计分配量达到阈值

对工程的实际影响:

  1. Unity 里不会出现"压缩搬动对象"的问题,原生插件缓存的对象地址是稳定的;但同时也没有压缩来消除碎片。
  2. 没有分代,每次 GC 都要扫描整个托管堆,标记成本与存活对象数量成正比。堆越大、常驻对象越多,单次卡顿越重——这才是 Unity 项目要拼命压低托管堆规模的根因。
  3. Unity 2020.2+ 提供 Incremental GC(增量 GC):把一次标记拆成多个时间片分摊到多帧,显著削掉单帧尖峰,但总工作量不变,且写屏障带来额外开销。
  4. Unity 里 GC.Collect() 依然可用,只是底层调用的是 Boehm 的全量回收。

一句话:学 .NET 的分代、压缩、LOH 没问题,但排查 Unity 的 GC 卡顿时,要按"不分代、不压缩、全堆标记"来想。

5. 分代回收(.NET GC 的核心优化)

代 存什么 回收频率 卡顿代价
Gen0 新建的短期对象 极高 很小,基本无感
Gen1 0 代回收后存活下来的对象 中等 低
Gen2 长期存活对象 极低 Full GC,高卡顿风险

晋升规则:0 代回收时存活的对象晋升到 1 代,1 代回收时存活的晋升到 2 代。

分代的意义:绝大多数对象朝生夕死,只扫 0 代就能回收掉大部分垃圾,避免每次都全堆扫描。

6. 大对象堆 LOH

大于等于 85000 字节的对象直接进入 LOH。LOH 默认不压缩,所以极易产生内存碎片——反复分配释放大数组,会出现"总空闲足够、但找不到连续大块"的情况。

7. GC 触发时机

  1. 自动触发:new 对象时对应代的托管堆空间不足(按需触发,不是定时);
  2. 操作系统内存压力;
  3. Unity 场景切换;
  4. 手动强制:GC.Collect()。

GC.Collect() 业务代码禁止随便调用。它会强制一次全堆回收(大概率 Full GC),代价极高;正确用法是放在加载界面等天然停顿点。

8. GC 带来的代价

  1. STW 卡顿:回收期间主线程冻结;.NET 的压缩阶段会额外加重开销,Unity 则是标记阶段与存活对象数量成正比;
  2. 内存碎片:只清除不压缩会留下空洞;
  3. 延迟释放:切断引用后对象不会立刻释放,要等下一轮 GC;
  4. 带析构函数的对象二次回收:先进终结器队列、回收两次,极易晋升到 Gen2 长期占用;
  5. GC 泄漏:与 C++ 的野指针泄漏不是一回事。这里不是内存丢失,而是引用被长期保留——事件忘记解绑、static 字段持有场景物体,对象永远可达、永远回收不掉。

9. Unity 里 GC 与引擎对象的关系

  • new 出来的 C# 类对象在托管堆,由 Mono / IL2CPP 自带的 GC 管理。
  • 销毁 MonoBehaviour 挂载的 GameObject 只销毁 C++ 侧的引擎对象,C# 侧的托管对象仍要等 GC 回收;反过来,C# 里的 GameObject 变量被 GC 回收也不会销毁场景中的物体。

10. 优化手段

GC 的分配来源就那么几类:频繁 new 临时托管对象、字符串拼接、装箱拆箱、协程迭代器分配。优化就是逐个掐掉它们。

1. 减少分配

  • 循环 / Update 里不要 new 对象:把临时集合提成成员字段,每轮 Clear() 复用。Clear() 只清元素、保留底层数组容量,不产生新的堆分配。
  • 字符串缓存:字符串不可变,a + b 每次都生成新字符串;高频拼接用 StringBuilder。
  • 避免装箱:值类型转 object 会在堆上分配,典型如 Debug.Log(整数) 也会装箱。
  • 协程也有分配:每次启动协程都会生成 IEnumerator 托管对象,高频创建协程同样产生 GC;大量等待逻辑改用统一的时间管理器。

2. 对象池

子弹、特效、树木石头这类高频创建销毁的物体,用对象池复用 GameObject,同时省掉 GC 和 Instantiate/Destroy 的引擎开销。

3. 主动回收

在加载界面等空闲窗口调用 GC.Collect(),把 Full GC 放在玩家感知不到的时机。

4. 用 Profiler 定位

Profiler 的 GC Alloc 指标能看到每帧的托管堆分配量,先定位再优化,不要凭感觉。

注意:IL2CPP 下依然有 GC。换成 IL2CPP 只是提升 C# 执行速度,分配和 STW 卡顿照样存在。

11. 常见误区集中

  1. ❌ "换成 IL2CPP 就没有 GC 了" —— IL2CPP 依然带 Boehm GC,分配与卡顿照旧,只是执行速度更快。
  2. ❌ "Unity 用的是分代 GC" —— 分代、压缩、LOH 都是 .NET CoreCLR 的模型;Unity 的 Boehm GC 不分代、不压缩。
  3. ❌ "调 GC.Collect() 能治内存泄漏" —— 泄漏的根因是引用没断(事件、静态字段、闭包),强制回收只会把可达对象再扫一遍,顺便送一次卡顿。
  4. ❌ "对象 Destroy 了内存就回来了" —— Destroy 只处理引擎对象,托管对象要等 GC,资源内存要等卸载 API。
  5. ❌ "SetActive(false) 就不占内存" —— 只是不渲染,对象和托管内存都还在。
  6. ⚠️ 增量 GC 不是免费的:它把一次长停顿拆成多次短停顿,总 CPU 开销反而略升,且写屏障对频繁写引用的代码有额外成本。