C# GC 原理:从 .NET 分代回收到 Unity 的 Boehm GC
GC 不是语言的一部分
C# 只规定”对象不再被使用后会被自动回收”,怎么回收由运行时决定。同一段 C# 代码,跑在不同运行时上,GC 的行为可能完全不同:
| 运行时 | GC | 分代 | 压缩 |
|---|---|---|---|
| .NET Framework / .NET(CoreCLR) | CLR GC | 是 | 是 |
| Mono 官方版本 | SGen | 是 | 是 |
| Unity(Mono 和 IL2CPP) | Boehm GC | 否 | 否 |
网上大多数”C# GC 原理”讲的是 .NET 的 CLR。本文先讲通用原理和 CLR,再讲 Unity 的 Boehm GC,最后讲两边通用的 Finalizer 与 Dispose。
一、通用原理
判断对象能否回收:可达性分析
GC 不用引用计数,而是从一组 **GC 根(GC Roots)**出发,沿着引用一路遍历,能走到的对象就是存活的,走不到的就是垃圾。
GC 根包括:
- 各线程栈上正在执行的方法中的局部变量和参数;
- CPU 寄存器中的引用;
- 静态字段;
- GC 句柄(比如被固定
pinned的对象); - 等待执行终结器的对象(见后文)。
所以两个对象互相引用,只要从根走不到它们,照样会被回收。引用计数解决不了的循环引用问题,在这里不存在。
基本算法
| 算法 | 过程 | 优缺点 |
|---|---|---|
| 标记-清除 | 标记所有存活对象,释放未标记的 | 简单,但会留下内存碎片 |
| 标记-压缩 | 标记后把存活对象移到一起,并更新所有指向它们的引用 | 没有碎片,分配快;但移动对象有成本 |
压缩后,空闲内存是一整块连续空间,分配新对象只需要移动一个指针(指针碰撞),非常快。
引用计数、复制算法、三色标记等其他 GC 算法的对比,见 Lua 核心知识:GC 算法总览。
精确式与保守式
- 精确式 GC:确切知道内存中哪些位置存的是引用。CLR 是精确式的。
- 保守式 GC:分不清某个值是引用还是一个恰好长得像地址的整数,只能”宁可错留,不可错杀”,把它当作引用。
保守式 GC 有两个后果:
- 可能误留本该回收的对象。
- 不能移动对象:如果移动了对象,就要更新指向它的引用,但它不确定那个”引用”是不是真的引用,改了可能会改坏一个普通整数。所以保守式 GC 通常也就无法压缩。
二、.NET CLR 的分代 GC
分代假说
大部分对象朝生夕死,活得越久的对象越可能继续活下去。
基于这个观察,CLR 把托管堆分成三代:
| 代 | 存放 | 回收频率 |
|---|---|---|
| Gen0 | 新分配的小对象 | 最频繁,空间小,回收很快 |
| Gen1 | 在 Gen0 回收中存活下来的对象 | 作为 Gen0 和 Gen2 之间的缓冲 |
| Gen2 | 长期存活的对象 | 最少,回收一次代价最大 |
- 对象在一次回收中存活下来,就晋升到下一代。
- 回收某一代时,会同时回收比它更年轻的所有代。回收 Gen2 就是一次完整回收(Full GC)。
- Gen0 的空间用完时,会触发一次 Gen0 回收。因为大部分对象此时已经死了,只需处理少量存活对象,速度很快。
分代的好处:大多数时候只扫描很小的 Gen0,而不是整个堆。
老年代引用新生代怎么办:卡表与写屏障
只回收 Gen0 时,不扫描 Gen2。但如果某个 Gen2 对象引用着一个 Gen0 对象,不扫描 Gen2 就会误判这个 Gen0 对象是垃圾。
CLR 的解决办法:
- 写屏障:每次把引用写入一个对象的字段时,运行时都会额外执行一小段代码。
- 卡表:写屏障发现是在老年代对象中写入了引用,就把这块内存所在的”卡”标记为脏。
- 回收 Gen0 时,除了 GC 根,还会扫描所有被标记为脏的卡。
代价是每次写引用都多一点点开销,换来不用扫描整个 Gen2。
大对象堆(LOH)
- 大于等于 85000 字节的对象直接分配在大对象堆。
- 逻辑上属于 Gen2,只在 Gen2 回收时才会被回收。
- 默认不压缩,因为移动大对象的成本太高,所以 LOH 容易产生碎片。可以通过
GCSettings.LargeObjectHeapCompactionMode要求下次回收时压缩一次。 - 典型的大对象是大数组。频繁创建、丢弃大数组会让 Gen2 回收变得频繁,应该复用(比如使用
ArrayPool<T>)。
GC 的几种模式
| 模式 | 特点 | 适用 |
|---|---|---|
| Workstation | 单个 GC 堆,回收在触发它的线程上执行 | 客户端程序(默认) |
| Server | 每个 CPU 核心一个 GC 堆和 GC 线程,吞吐量大 | 服务端程序 |
| 后台 GC | Gen2 回收在后台线程进行,期间应用线程仍可运行和分配 | 默认开启,减少 Full GC 造成的停顿 |
Gen0 和 Gen1 的回收(合称短暂代回收)仍然需要暂停所有托管线程(Stop-The-World),但因为范围小,时间很短。
三、Unity 的 Boehm GC
Unity 目前的两种脚本后端(Mono、IL2CPP)都使用 Boehm GC。它和 CLR 的差别很大:
特点
- 不分代:每次回收都要标记整个堆中的存活对象。堆越大、存活对象越多,单次回收越慢。
- 不移动对象、不压缩:会产生碎片。碎片多时,即使空闲内存总量足够,也可能找不到一块足够大的连续空间,只好扩容。
- 保守式扫描栈:扫描栈和寄存器时是保守的,这也是它不能移动对象的原因之一。
- Stop-The-World:默认情况下,回收期间主线程完全停住,直接表现为一帧卡顿。
什么时候触发 GC
分配对象 └─ 托管堆中有足够的空闲空间? ─ 是 → 直接分配 └─ 否 → 执行一次 GC └─ 回收后够了? ─ 是 → 分配 └─ 否 → 向系统申请扩大托管堆所以在 Unity 里,分配得越多,GC 越频繁;堆越大,每次 GC 越慢。而托管堆扩容后很少缩回去,一次分配高峰可能让之后每次 GC 都更慢。
这就是 Unity 开发中强调”每帧零分配”的根本原因,具体做法见 Unity 性能优化总览。
增量 GC
Unity 2019.1 起提供增量 GC(Player Settings → Use incremental GC,新版本默认开启)。
- 原理:把一次完整回收的标记工作拆成多个小片段,分散到多帧执行,每帧只占用一小段时间。
- 写屏障:标记进行到一半时,程序还在继续修改引用。为了不漏标对象,增量模式会给引用写入加上写屏障,记录这些修改。这会给代码带来一些额外开销。
- 局限:
- 它不减少 GC 的总工作量,只是把尖峰摊平。
- 如果分配速度太快,或者在两次片段之间引用变化太多,GC 可能来不及完成,还是会出现明显的停顿。
增量 GC 是缓解手段,减少分配才是根本。
手动控制 GC
可以通过 UnityEngine.Scripting.GarbageCollector 控制 GC 的行为:
using UnityEngine.Scripting;
// 关卡开始:关闭自动 GCGarbageCollector.GCMode = GarbageCollector.Mode.Disabled;
// 关卡结束、进入加载界面:恢复并主动回收GarbageCollector.GCMode = GarbageCollector.Mode.Enabled;System.GC.Collect();| 模式 | 行为 |
|---|---|
Enabled | 正常自动 GC(默认) |
Disabled | 完全关闭 GC,包括手动调用 GC.Collect() 也不生效 |
Manual | 关闭自动 GC,但允许手动调用 GC.Collect() 或 GarbageCollector.CollectIncremental() |
关闭 GC 期间托管堆只增不减,适合分配量可控、时间有限的场景(比如一局战斗),并且要监控内存,避免撑爆。
未来
Unity 已公布迁移到 CoreCLR 的计划,完成后会改用 CLR 的分代 GC。在此之前的版本,以上结论都成立。
四、Finalizer 与 Dispose
这部分 CLR 和 Unity 都适用。
GC 只管托管内存
GC 能回收托管对象,但管不了文件句柄、网络连接、原生内存、NativeArray 这些非托管资源。释放它们有两种机制:
| Finalizer(终结器) | Dispose | |
|---|---|---|
| 写法 | ~MyClass() { } | 实现 IDisposable.Dispose() |
| 谁调用 | GC,在终结器线程上 | 使用者主动调用 |
| 时机 | 不确定 | 确定,用完立刻释放 |
| 定位 | 兜底:忘了 Dispose 时最后的保障 | 正常的释放途径 |
为什么终结器会拖慢回收
- 带终结器的对象在创建时会被登记到终结队列中。
- GC 发现它不可达时,不能直接回收,而是把它移到”待终结”队列。这个队列也是 GC 根,所以对象在这次回收中被复活了(在 CLR 中还会晋升一代)。
- 终结器线程稍后执行它的终结器。
- 下一次 GC 时,它才真正被回收。
所以带终结器的对象至少要经历两次 GC 才能释放,而且它引用的所有对象也跟着多活一轮。没有非托管资源就不要写终结器。
另外,终结器的执行顺序和执行线程都不确定,在终结器里不要访问其他托管对象,在 Unity 中也不要调用 Unity API(它们只能在主线程调用)。
Dispose 模式
public class ResourceHolder : IDisposable{ IntPtr _handle; // 非托管资源 FileStream _stream; // 实现了 IDisposable 的托管对象 bool _disposed;
public void Dispose() { Dispose(true); GC.SuppressFinalize(this); // 已经手动释放过,告诉 GC 不必再执行终结器 }
~ResourceHolder() => Dispose(false);
protected virtual void Dispose(bool disposing) { if (_disposed) return; if (disposing) { // 由 Dispose() 调用:可以安全地释放其他托管对象 _stream?.Dispose(); } // 两种情况都要释放非托管资源 FreeHandle(_handle); _disposed = true; }}要点:
disposing为true表示是使用者主动调用,可以访问其他托管对象;为false表示来自终结器,其他托管对象可能已经被回收,不能再碰。GC.SuppressFinalize(this)把对象从终结队列中移除,让它可以在一次 GC 中直接回收。- 用
_disposed防止重复释放。
using
using (var stream = File.OpenRead(path)){ // ...}
// C# 8 起的简写,变量离开作用域时自动 Disposeusing var stream = File.OpenRead(path);using 会被编译成 try { ... } finally { stream?.Dispose(); },即使中途抛出异常也能保证释放。
五、弱引用与托管内存泄漏
弱引用
WeakReference<T> 持有对象,但不阻止它被回收。适合做缓存:内存充足时还能拿到,被回收了就重新创建。
var cache = new WeakReference<BigData>(data);if (cache.TryGetTarget(out var target)) { /* 还活着 */ }有 GC 也会内存泄漏
GC 只回收”不可达”的对象。不再使用、却仍然被引用着的对象,GC 无能为力,这就是托管内存泄漏。常见原因:
- 事件没有取消订阅:
publisher.OnXxx += subscriber.Handle之后,发布者持有订阅者的引用。发布者活多久,订阅者就活多久。在 Unity 中尤其常见:MonoBehaviour 订阅了静态事件,OnDestroy时忘了取消,对象销毁后 C# 壳仍然留在内存中(见 Unity 内存构成)。委托和事件的原理见 委托、事件与 Lambda。 - 静态集合:只往里加、从来不删。
- 闭包捕获:长期存在的委托捕获了大对象。
- 缓存没有上限。
常见追问
GC 怎么判断一个对象是垃圾? 从 GC 根出发做可达性分析,走不到的就是垃圾。不是引用计数,所以循环引用也能被回收。
为什么要分代? 大部分对象很快就会死,只频繁回收新生代,每次只需处理很小的一块内存,比每次扫描整个堆快得多。
老年代对象引用了新生代对象,只回收新生代时怎么办? 写屏障在引用写入时,把老年代中被修改的区域标记到卡表里,回收新生代时额外扫描这些区域。
什么是大对象堆? 85000 字节以上的对象分配在大对象堆,属于 Gen2,默认不压缩,容易产生碎片。大数组应该复用。
Unity 的 GC 和 .NET 的有什么不同? Unity 用的是 Boehm GC:不分代、不压缩、保守式扫描栈,默认会暂停主线程完成整个回收。所以 Unity 对”每帧零分配”的要求比普通 .NET 程序严格得多。
增量 GC 解决了什么问题?代价是什么? 把一次回收拆到多帧完成,减少单帧卡顿;代价是写屏障带来的额外开销,而且不减少总工作量。
Finalize 和 Dispose 有什么区别? Dispose 由使用者主动调用,时机确定;Finalize 由 GC 调用,时机不确定,只作为兜底。带终结器的对象至少要两次 GC 才能被回收。
为什么 Dispose 里要调用 GC.SuppressFinalize?
资源已经手动释放了,没必要再执行终结器;从终结队列中移除后,对象可以在一次 GC 中直接回收。
有 GC 为什么还会内存泄漏? GC 只回收不可达的对象。事件未取消订阅、静态集合、长期存在的闭包会让无用的对象一直保持可达。
文章分享
如果这篇文章对你有帮助,欢迎分享给更多人!