C# GC 原理:从 .NET 分代回收到 Unity 的 Boehm GC

3305 字
17 分钟
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 有两个后果:

  1. 可能误留本该回收的对象。
  2. 不能移动对象:如果移动了对象,就要更新指向它的引用,但它不确定那个”引用”是不是真的引用,改了可能会改坏一个普通整数。所以保守式 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 线程,吞吐量大服务端程序
后台 GCGen2 回收在后台线程进行,期间应用线程仍可运行和分配默认开启,减少 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;
// 关卡开始:关闭自动 GC
GarbageCollector.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 时最后的保障正常的释放途径

为什么终结器会拖慢回收#

  1. 带终结器的对象在创建时会被登记到终结队列中。
  2. GC 发现它不可达时,不能直接回收,而是把它移到”待终结”队列。这个队列也是 GC 根,所以对象在这次回收中被复活了(在 CLR 中还会晋升一代)。
  3. 终结器线程稍后执行它的终结器。
  4. 下一次 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 起的简写,变量离开作用域时自动 Dispose
using 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 只回收不可达的对象。事件未取消订阅、静态集合、长期存在的闭包会让无用的对象一直保持可达。

文章分享

如果这篇文章对你有帮助,欢迎分享给更多人!

C# GC 原理:从 .NET 分代回收到 Unity 的 Boehm GC
https://xslab.cloud/posts/csharp/garbage-collection/
作者
LuxFire
发布于
2026-10-09
许可协议
CC BY-NC-SA 4.0
相关文章 智能推荐
1
Unity 内存构成:托管内存、原生内存与显存
Unity底层/资源与内存 一个 Unity 游戏的内存由哪几块组成、分别由谁分配和释放。重点讲 UnityEngine.Object 的"托管壳 + 原生本体"结构,以及资源卸载、显存估算和内存排查工具。
2
Unity 性能优化总览:从定位问题到 C#、引擎与渲染
Unity性能优化 Unity 常见性能优化点的总览。先讲怎么定位瓶颈,再按 C# 代码、Unity 对象与 API、渲染、UI、内存与加载分类整理,复杂主题链接到专题文章。
3
设计模式在 Unity 中的应用:单例、观察者、命令、状态、工厂、策略等
C#底层/面向对象 游戏开发中最常用的设计模式及其在 Unity 中的实现与陷阱:单例的几种写法和滥用问题;观察者与事件中心;命令模式实现输入、撤销与回放;状态模式;对象池;工厂;策略;模板方法;享元与 ScriptableObject;外观;服务定位器与依赖注入;以及 UI 中的 MVC、MVP、MVVM。
4
C# 关键字速查
C#底层/关键字 按类别整理 C# 常用关键字,每个一两句话说明用途和要点,复杂的关键字链接到专题文章。适合复习时快速过一遍。
5
C# 迭代器与 async/await 原理:编译器生成的状态机
C#底层/关键字 yield return 和 async/await 编译后分别变成了什么;状态机如何保存局部变量、如何从中断处继续;awaiter 模式;async 状态机什么时候会分配堆内存;SynchronizationContext 决定 await 之后在哪个线程继续;以及"异步不等于多线程"。
随机文章 随机推荐
Profile Image of the Author
LuxFire
Hello, I'm LuxFire.
公告
欢迎来到我的博客!这是一则示例公告。
音乐
封面

音乐

暂未播放

0:00 0:00
暂无歌词
分类
标签
站点统计
文章
60
分类
6
标签
164
总字数
171,869
运行时长
0 天
最后活动
0 天前

文章目录