Unity 增量式 GC 架构解析
篇章:03-架构篇 | 阅读时间:约 45 分钟 | 前置知识:了解增量式 GC 概念
一、引言
Unity 在 2019.1 首次引入 Incremental GC。它当时以实验特性的身份出现在 Player Settings 中,需要手动勾选;经过几个版本的迭代,后续 Unity 版本把它变成了默认开启的正式选项。它要解决的问题很单一:把 GC 那种几十毫秒的整段停顿拆开,摊到连续的多帧里,让每帧只承担几毫秒的开销。
动配置之前,先纠正一个流传很广的误解:Unity 的增量 GC 不是 SGen 的增量改造,也不是一个独立的新收集器。官方文档的表述很明确,Unity 使用 Boehm-Demers-Weiser 收集器,并且默认以增量模式运行,Mono 与 IL2CPP 两个脚本后端用的都是它。所以"Unity 增量 GC"的准确含义是 Boehm 的 incremental mode(底层对应 GC_enable_incremental 一族接口),加上 Unity 在引擎侧做的调度与封装。Boehm 本身非分代、非压缩、保守式识别引用,这些性质在增量模式下一条都没有变。
本文按"原理、定位、机制、代价、限制、评估"的顺序展开:先讲清设计思路与权衡(第二节),明确它在 GC 架构中的位置(第三节),再拆解标记机制与写屏障(第四、五节),随后是时间预算、回退与受限场景(第六到第八节),最后是配置 API、性能评估与架构对比(第九到第十一节)。
二、设计原理
2.1 问题背景
Boehm 在非增量模式下的一次收集是完整的 stop-the-world:暂停所有托管线程,标记整个堆,清扫,然后恢复运行。单次暂停的长度与堆大小、存活对象数量成正比。堆涨到 100MB 量级时,一次全量标记加清扫出现 50ms 上下的停顿并不罕见(示例量级,实际取决于堆布局、存活率与硬件)。
50ms 对游戏意味着什么?60FPS 下每帧预算只有 16.7ms,一次 50ms 的停顿会直接吃掉 3 帧左右;暂停到 100ms 就是 5、6 帧。GC 停顿最麻烦的地方是它的突发性:前一帧输入响应正常,这一帧整个世界冻结,下一帧又恢复正常,玩家感知到的是规律性的顿挫,而不是平均帧率的下降。画质、逻辑复杂度都救不了它,因为停顿全部发生在收集器内部。
背后还有一层结构性原因:Boehm 不分代,没有新生代那种小步快跑的回收缓冲,每一轮收集都要面对整堆,堆越大、存活对象越多,暂停就越长。移动项目的堆又往往随运行时间只涨不掉,单次时长和触发频率会一起恶化。这就是增量改造被提上日程的直接背景。
2.2 时间分片
增量式 GC 的思路是把"一次做完"改成"每帧做一点"。同一段标记工作在两种模式下的时间线差异如下:
非增量(普通模式,一次性 STW 标记):
帧 N-1 帧 N 帧 N+1
[运行] [========= 50ms 全停:标记 + 清扫 =========] [运行]
↑ 这一段里 3 帧的逻辑与渲染全部冻结
增量(时间分片标记,每帧 3ms 时间片):
帧 N 帧 N+1 帧 N+2 帧 N+3 帧 N+4 帧 N+5 帧 N+6
[+3ms] [+3ms] [+3ms] [+3ms] [+3ms] [+3ms] [收尾]
└──────────── 同样的标记工作摊到多帧,每帧只多出 3ms ────────────┘
(3ms 为典型估算量级,不是固定常数,实际由帧预算与堆规模共同决定。)
2.3 关键权衡
增量不是免费的,它是一笔明确的交易:用更高的总 CPU 消耗,换更低的单帧峰值暂停。
- 峰值暂停:从"随堆增长的几十毫秒"压到时间片量级,每帧 3ms 上下(典型估算)。
- 总 CPU 时间:一轮增量周期的总耗时通常比非增量高出 30% 到 50%(典型估算,不是实测常数)。开销来自三处:写屏障在每次引用写入时附加的指令;标记被摊薄后缓存局部性变差;跨帧维护标记状态本身的成本。
- 附带收益:暂停变得可预测。堆再大,单帧的 GC 开销也被时间预算封顶,帧时间从不可控变成可控。
对游戏这类延迟敏感的负载,这笔交易几乎是稳赚的。玩家对平均帧率的感知远弱于对卡顿尖峰的感知,总吞吐略降、偶发冻结大幅减少,正是帧率优化想要的方向。
三、架构定位:与 Boehm 的关系
3.1 官方定位
Unity 官方文档写得直接:Unity 的垃圾收集器使用 Boehm-Demers-Weiser 收集器,默认以增量模式运行,Mono 后端与 IL2CPP 后端都使用它。由此可以推出三条结论:
- Unity 的 GC 底座自始至终是 Boehm,不存在一个"Unity 自研收集器";
- 开启增量不是切换到另一个 GC,而是同一个 Boehm 打开 incremental 开关,底层即
GC_enable_incremental; - 非分代、非压缩、保守式扫描这三条性质原样保留。对象永远不被移动,堆里的空洞只能靠空闲链表复用,碎片不会因为开了增量而消失。
3.2 非增量与增量的结构对比
非增量(全量 STW 标记):
触发
│
▼
┌──────────────────────────────────────┐
│ STW:根扫描 → 标记整个堆 → 清扫整个堆 │ 暂停时长 ≈ O(堆大小)
└──────────────────────────────────────┘
│
▼
恢复运行
增量(Boehm 增量模式,分片标记):
触发
│
▼
[短暂 STW] 初始标记:扫描根,建立标记起点
│
▼
[帧 k] 推进标记 ←─┐
[帧 k+1] 推进标记 │ GC_collect_a_little / GC_mark_some
[帧 k+2] 推进标记 │ 每次只推进一小步,标记状态跨帧保留
[帧 k+n] 推进标记 ──┘
│
▼
[短暂 STW] 最终标记:处理增量期间积累的脏区域
│
▼
清扫(一次性完成,通常很快) → 恢复运行
3.3 与 SGen 的界线
"Unity 增量 GC 是 SGen 的运行模式"这个说法需要明确否定,历史上的实际情况是这样的:
- SGen 曾经在 Unity 内部被实验性地试过,但从未随产品发布;
- 团队最终选择在 Boehm 上做时间分片标记,理由是改动最小:Boehm 已经稳定跑在两个后端上,把标记过程切片不需要动收集器的其他部分;
- 所以 Unity 增量 GC 既不是 SGen 的一部分,也不是"SGen 加分片",它的准确描述只有一个:Boehm + 时间分片标记。
把它理解成"Boehm 的一种运行模式"还有实用价值:关掉增量开关,你得到的就是原生 Boehm 的全量 STW 收集。两者共享同一套堆、同一套对象布局、同一套保守扫描逻辑,来回切换没有迁移成本。顺带一提,SGen 是上游 Mono 运行时自带的分代收集器,很多"Unity 用 SGen"的说法就来源于此,它并不在 Unity 的增量链路里。
四、增量标记的工作机制
4.1 四个阶段
一轮增量收集分为四个阶段,只有中间的推进阶段跨帧:
| 阶段 | 执行方式 | 工作内容 | 典型耗时(示例) |
|---|---|---|---|
| 1. 初始标记 | 短暂 STW | 扫描根(栈、静态字段、注册根),确定起点 | 0.1ms 量级 |
| 2. 增量标记 | 跨多帧,每帧一个时间片 | 从灰色对象出发逐层推进对象图 | 每帧 3ms 量级 |
| 3. 最终标记 | 短暂 STW | 补扫增量期间被改写的区域,收口标记 | 0.1ms 量级 |
| 4. 清扫 | 一次性 | 回收未标记对象的内存,不分片 | 1ms 量级 |
清扫不进入分片是有原因的。Boehm 是标记-清扫式且不移动对象,清扫只是把未标记的块挂回空闲链表,速度远快于标记,也不改对象图,为它引入跨帧状态得不偿失。
4.2 从 Boehm 看推进接口
从 Boehm 的接口视角,增量推进的入口是 GC_collect_a_little,它内部通过 GC_mark_some 执行一小段标记工作后返回。返回值区分两种情况:这一小步做完但整轮未完成,或者标记已经收尾。未完成时,引擎在后续帧继续调用,直到标记结束才进入清扫。标记栈与进度游标这些状态保存在 GC 管理的持久区域里,跨帧保留,因此任意一帧中断后,下一帧都能从断点精确续上。
初始根扫描必须 STW,因为扫描根的同时应用线程可能正在改写栈上的引用。好在根扫描通常在 0.1ms 量级(示例值),不是暂停的大头。真正被切片的是中间遍历对象图的部分,也就是耗时与堆大小成正比的那一段。
还有个容易忽略的细节:标记窗口内新分配的对象怎么办。答案是它们出生即按已标记处理,不会被这一轮清扫误伤,也不需要回头补扫。代价在于增量窗口拉得越长,这类边扫边生的对象就越多,堆在标记期间持续膨胀,正是回退风险的来源之一(见第七节)。
4.3 写屏障与脏位
增量标记最难的不是分几次做完,而是做的过程中世界还在变。标记开始后,应用线程可能把一个已扫描对象的引用改指向一个尚未标记的对象。没有拦截的话,这个新引用指向的对象会被漏标,清扫时被当成垃圾回收,随后就是难以定位的空引用崩溃。
Boehm 的应对是记录脏区域:
- 非增量模式下,标记期间没有应用代码运行,开始时把整堆视为脏即可,不需要细粒度记录;
- 增量模式下必须边跑边记。Boehm 的传统手段是虚拟脏位(virtual dirty bits,VDB):用
mprotect把堆页设为只读,应用线程写入触发缺页异常,处理函数把该页标脏后放开写权限,GC 最后只需复查这些脏页;在支持硬件跟踪的平台上则直接用系统提供的写跟踪能力; - Unity 侧的配套改动是:增量模式下额外为托管代码生成写屏障,引用字段的写入会顺带标记对应的脏页或脏卡。
最终标记阶段(第三次 STW)要做的就是把脏区域重新扫一遍,凡是增量期间新增或改写的引用补上标记。四阶段的顺序设计,正是为了让分片推进与引用持续变化这两件事同时成立。Boehm 本身是保守式收集器,可疑的值会被多看一眼,这进一步压低了漏标风险,代价是可能保留本该死掉的对象。
五、写屏障的代价
5.1 引用写入变慢
写屏障不免费。非增量模式下,引用赋值就是一条普通存储指令;开启增量后,Unity 必须为引用字段的写入额外生成屏障代码,告诉 GC 这块内存动过了。单次开销只有几条指令,但引用写入是游戏代码里频率最高的操作之一,频率乘以指令数,累积起来能被 Profiler 看到。
5.2 哪些代码受影响
最吃紧的是引用写入密集的 tight loop:
- 每帧大量改写引用的容器操作,反复塞入、清空、交换引用;
- 粒子、寻路、行为树这类逐帧改引用字段的系统;
- 热循环里对类字段的反复赋值。
// 增量模式下,每次迭代都要多付一次写屏障
for (int i = 0; i < buffer.Length; i++)
buffer[i].next = scratch[i]; // 引用写入 → 触发屏障
纯值类型写入与非托管内存写入不受影响,它们不涉及托管引用变更。这也是"能用 struct 搬数据就别搭 class 引用链"在增量模式下收益更直接的原因。
5.3 与非增量模式的对比
| 维度 | 非增量(全量 STW) | 增量(分片标记) |
|---|---|---|
| 引用写入成本 | 无屏障,原始写入 | 每次写入附带屏障指令 |
| GC 执行方式 | 周期性一次性长暂停 | 每帧小片推进 |
| 总 CPU 消耗 | 基线 | 典型估算高出 30%~50% |
| 帧时间形态 | 规律性尖峰 | 平稳,偶发回退尖峰 |
所以增量并非在所有项目里都更快。堆很小、GC 很少触发、但引用写入极其频繁的项目,可能只感受到吞吐的轻微下降。开不开、开了有多大收益,要靠 Profiler 数据说话,直觉靠不住。
六、时间预算与帧尾空闲时间
6.1 默认按帧的剩余时间工作
增量标记每帧推进多少,取决于这一帧还剩多少时间。默认策略就是吃帧尾:渲染和逻辑跑完之后,如果本帧还有剩余预算,GC 就用它推进一片标记。
换成具体数字感受一下:16.7ms 的帧预算里扣掉 3ms 的时间片,留给逻辑和渲染的还有 13ms 以上,多数场景吸收得了;同样 3ms 落进本就吃紧的帧,就会直接顶破预算。所以增量 GC 在帧本身有余量的项目里效果最好,在已经超帧的项目里只是把停顿挪了地方,帧预算本身还是得先治。
6.2 VSync 与 targetFrameRate 决定有没有帧尾
存在帧尾空闲是有前提的。Unity 的行为是:
- 设置了 VSync(垂直同步不为 Don't Sync)或者设置了
Application.targetFrameRate时,帧与帧之间存在等待窗口,Unity 会自动利用这些空闲时间推进增量标记; - 两者都没设、任由帧率跑满时,每帧被逻辑和渲染塞满,没有天然空闲,增量推进的空间被压缩,一轮标记可能拖得更久,完不成时更容易触发回退(见第七节)。
所以启用增量 GC 的项目,最好把目标帧率或 VSync 一起配好,这两件事是配套的。
6.3 手动控制时间片
需要更精确的控制时,GarbageCollector.incrementalTimeSliceNanoseconds 可以手动指定每片的时间预算,单位是纳秒。设为 0 表示不限制单次时长;设为具体数值则每次推进不超过该时长。常见用法是加载期临时调大让一轮收集尽快完成,进入帧敏感阶段前调小,把 GC 压进空闲缝隙里。
6.4 一次增量周期的帧时间分布示例
帧 0(触发):初始标记 STW 0.1ms + 增量标记 3.0ms = 3.1ms
帧 1~帧 5: 增量标记 3.0ms × 5 帧 = 15.0ms
帧 6(收尾):最终标记 STW 0.1ms + 清扫 1.0ms = 1.1ms
------------------------------------------------------------
GC 总耗时 19.2ms,摊在帧 0 到帧 6 共 7 帧上,单帧最大 3.1ms
对照:同一堆规模下非增量模式的一次性停顿约 50ms
(以上为示例数据,用于说明分摊结构,不代表任何项目的普适实测值。)
这里不要把 19.2ms 和 50ms 读成"增量总时间更短"。真实场景里增量的总耗时通常更高,写屏障与分片都会加钱,这组数字想说明的只是结构变化:单帧峰值从 50ms 掉到 3ms 量级,3 帧的冻结消失,换成 7 帧里各多花几毫秒。
七、增量失败与回退
7.1 什么时候会回退
增量标记本质上是边跑程序边做标记。如果程序改引用的速度超过 GC 推进的速度,标记会一直无法收敛:刚补上的脏区域又被改脏,进度原地踏步。Boehm 不会让这个状态无限持续,超过限制后回退(fallback)为一次性的全量 STW 收集,在一个暂停里把整轮工作做完。
回退是安全兜底,不会导致崩溃,但代价实打实:这一轮同时付了若干帧的增量开销,最后还得挨一记接近非增量水平的长暂停,增量的收益在这一轮归零,属于最差情况。
7.2 什么模式容易触发回退
两类行为叠加时最容易踩到:
- 高分配速率:每帧产生大量临时对象,标记期间堆持续膨胀,标记追不上新分配的速度;
- 高频引用改写:每帧重建大对象图、反复清空再填充集合、大量交换引用,脏区域率居高不下。
具体例子包括每帧用字符串拼接堆日志和协议、每帧反序列化一大坨 JSON 再立刻改写整棵树、没有池化的特效数据流。识别信号在 Profiler 里很清楚:大部分帧的 GC 都很短,却周期性冒出一帧很长的 GC.Collect,通常就是回退。
7.3 应对
思路还是回到分配本身:把分配速率降下来,池化、复用、缓存结果;把"重建大对象图"的重活挪到加载期或低频节点,让战斗帧里的对象图保持稳定。增量 GC 解决的是暂停长度问题,解决不了分配太多问题,别指望一个开关打包解决两件事。
八、不支持与受限的场景
8.1 WebGL 不支持
WebGL 平台不支持增量 GC。勾选了 Use Incremental GC 也不会生效,构建跑的仍然是非增量路径。面向 Web 发布的项目,卡顿治理只能靠减少分配与加载期收集,指望分片是没戏的。
8.2 Unity 6 的 CoreCLR 后端不支持
Unity 6 引入的 CoreCLR 后端用的是 .NET 自带的 GC,不走 Unity 这套 Boehm 增量机制,Use Incremental GC 对它无效。项目迁到 CoreCLR 之后,评估对象应该换成 .NET 的后台 GC 与 Server GC 配置,本文的分析不适用。
8.3 Editor 与 Player 的行为差异
Editor 的帧结构和 Player 不一样:编辑器自身的重绘、菜单、多窗口都会干扰帧节奏,帧尾空闲时间的分布也完全不同。同一个项目在 Editor 里看到的切片长短、回退频率,跟真机可能相差很远。所有关于增量 GC 的性能结论都必须以 Development Build 连真机 Profiler 的数据为准,Editor 里的观察只用来确认开关生效。
九、配置与 API
9.1 开关路径
启用入口在 Project Settings > Player > Other Settings > Configuration > Use Incremental GC(编辑器里就是 Edit → Project Settings → Player → Other Settings → 勾选 Use Incremental GC)。这是构建期配置,勾上之后打包生效,对业务代码完全透明,不需要改任何调用。
9.2 模式与 API
运行时用 GarbageCollector.GCMode 查询与切换,它有三个取值:
| 取值 | 行为 | 典型用途 |
|---|---|---|
Incremental | 自动回收,优先走增量路径 | 默认,正常运行期 |
Manual | 不自动触发,只响应显式调用 | 自己按帧泵收集的框架 |
Disabled | 关闭自动回收,仅 System.GC.Collect() 显式触发 | 极短的受控窗口 |
三个核心 API 的分工:
GarbageCollector.CollectIncremental():推进一次增量收集,返回值告诉你这轮是否已经完成。Manual 模式下由自己按帧调用,相当于手动版的自动推进。System.GC.Collect():无视当前模式,立刻做一次全量阻塞收集,等于一次性付清。适合加载完成点、关卡切换这类非帧敏感时刻。GarbageCollector.isIncremental:只读查询当前是否真的运行在增量模式,受设置与平台共同决定,适合启动时打日志确认,WebGL 上它就是 false。
9.3 加载期禁用 GC:做法与风险
一个常见技巧是进 loading 前把 GCMode 设为 Disabled,加载完再恢复,避免收集器在加载过程中插入一次长暂停。收益明确,风险也必须讲清楚:禁用期间分配只增不减,如果加载资源本身很大,或者反复进出同一批加载,堆可能在恢复之前就顶到内存上限,低端机上直接分配失败;更隐蔽的是恢复路径,一旦加载流程抛异常或回调没走到,GC 会一直关着,后面越跑越危险。
稳妥写法是三步:禁用前先 System.GC.Collect() 腾出余量,恢复放进 finally 或状态机的必经路径,恢复后再收集一次清底。只在时长可控、分配量可估的短加载上用它,把它当常驻配置是拿 OOM 换少掉几帧,通常不划算。
9.4 实际项目启用指南
- 先排除不适用平台:WebGL 与 CoreCLR 后端直接跳过;
- 勾选 Use Incremental GC,同时确认 VSync 或
Application.targetFrameRate已配置,保证帧尾有空闲; - 出 Development Build,连 Profiler 跑最重的几个场景:战斗、大场景加载、UI 堆叠;
- 记录启用前后的 P99 帧时间、最大帧时间、掉帧次数,别只记平均值;
- 对照 Timeline 看 GC 段是否从长条变成碎段;仍是长条就说明在回退,回到第七节先把分配压下去;
- 只有短加载有需要时才引入 Manual 或 Disabled 模式,并按 9.3 的清单检查恢复路径。
勾上开关只是第一步,真正的收益要拿真机数据验收,别停在 Editor 里看一眼就宣布完工。
十、性能对比与评估方法
10.1 评估误区:平均帧时间骗人
评估增量 GC 最常见的错误是只看平均帧时间。增量天生会让平均值轻微变差:写屏障拉长了每次引用写入,标记摊到更多帧上,总 CPU 也更高。拿启用前后的平均值做验收,很容易得出"没用甚至更慢"的错误结论,而真正的收益完全没被衡量。
该盯的是分布的尾部:
- P99 帧时间与最大单帧 GC 暂停,这是增量直接优化的对象;
- 卡顿帧数量,超过 16.7ms(60FPS)或 33.3ms(30FPS)的帧是否明显减少;
- 帧时间方差,帧节奏是否更稳;
- 顺带盯总 CPU,确认额外开销在可接受范围,典型估算三到五成。
可靠的评估姿势是同场景 A/B:同一个存档、同一条路径,启用前后各跑固定时长,采集完整帧时间序列后比较分位数与卡顿帧计数,而不是截图某一次表现。采样段要覆盖 GC 密集的时刻,比如战斗中段和连续切场景,否则测到的只是空闲期的假象。
10.2 项目实测示例:87ms 到 4ms
某个项目的实测示例(单项目数据,非普适结论):同一场景、同一堆规模下,非增量模式(全量 STW 标记)的最大单次 GC 暂停为 87ms,勾选 Use Incremental GC 后最大单次暂停降到 4ms。87ms 在 60FPS 下是连续 5 帧以上的冻结,4ms 完全落在单帧预算内,玩家反馈的周期性顿挫随之消失;代价是该轮 GC 总耗时上升,和第二节的权衡一致。
非增量:[========= 87ms =========] 单次长冻结,连掉 5 帧
增量: [4ms][4ms][4ms][4ms] ... [4ms] 每帧一小段,落在预算内
10.3 Profiler 中如何验证
四个观察点,按顺序做:
- CPU 模块的 Timeline,找以
GC.Collect命名的暂停段:启用前是单帧一根长条,启用后应是分散在多帧的小段;仍频繁出现长条就是在回退; - 帧时间尖峰与 VSync 的对齐关系,确认切片是否吃在帧尾空闲里;
- Memory 模块的 GC Alloc 曲线(例如
GC Allocated In Frame计数器),注意增量 GC 不减少分配,它只重排暂停,所以这条曲线本该基本不变;曲线在涨是分配问题,另案处理; - 想看更细的分片,临时把
incrementalTimeSliceNanoseconds调小,让一轮收集跨更多帧,对比前后的帧时间分布。
十一、架构对比
把四种放在一起对照。注意表里的 Mono SGen 是上游 Mono 运行时自带的收集器,列出来只为划清界限,Unity 的增量链路与它无关:
| 架构 | 分代 | 并发 / 增量 | 压缩 | 适用场景 |
|---|---|---|---|---|
| Mono SGen(对照) | 2 代(Nursery + Major) | 可选并发标记 | 支持 | 上游 Mono 运行时的通用场景 |
| Boehm(非增量) | 无 | 无,全量 STW 标记 | 不压缩 | Unity 传统全量回收路径 |
| Unity 增量 GC(Boehm + 时间分片) | 无 | 增量标记,分帧推进 | 不压缩 | Unity 项目压峰值暂停 |
| .NET Core GC | 3 代 + LOH | 后台 GC | 支持 | 服务器与 Unity 6 CoreCLR 后端 |
读表有三个要点。第一,Unity 增量 GC 与非增量 Boehm 是同一个收集器的两种运行模式,差别只在标记怎么执行,堆管理完全一致。第二,两者都不分代、不压缩,所以"堆只涨不掉、碎片持续累积"这类长期问题不在增量的职责范围内。第三,要根治还是两条腿走:代码层面把分配降下来、控制堆规模,运行时层面必要时迁到 CoreCLR 后端,把 GC 换成 .NET 那套分代加压缩的方案。
总结
Unity 增量 GC 的要点可以收成几句话。
它是 Boehm GC 的增量运行模式,Boehm 加时间分片,Mono 与 IL2CPP 后端通用。不是 SGen,也不是独立的新收集器,关掉开关就是原生 Boehm 全量回收。
机制是四阶段:短暂 STW 初始标记、跨帧推进标记、短暂 STW 最终标记、一次性清扫。写屏障与脏位记录在增量期间兜住对象图一致性,帧尾空闲时间是它的工作窗口,incrementalTimeSliceNanoseconds 是手动旋钮。
代价与边界同样清楚:总 CPU 典型估算高出三到五成,引用写入密集的代码要多付屏障,改写过快会回退成全量 STW,WebGL 与 Unity 6 CoreCLR 后端用不上,Editor 数据不能当验收依据。
评估看 P99 与卡顿帧数量,不看平均帧时间。启用只是一个开关的距离,真正的长期收益来自把分配降下来,让增量 GC 有完成一轮标记的喘息空间。
代码示例:检测与控制增量 GC
using UnityEngine;
public static class IncrementalGCDemo
{
// 启动时确认状态:WebGL 上 isIncremental 恒为 false
public static void LogGCStatus()
{
Debug.Log($"incremental={GarbageCollector.isIncremental}, " +
$"mode={GarbageCollector.GCMode}");
}
// 手动控制每片预算:2ms,只给 GC 留小缝隙
public static void SetTimeSlice(long nanoseconds)
{
GarbageCollector.incrementalTimeSliceNanoseconds = nanoseconds;
}
// Manual 模式下由自己按帧泵收集
public static bool PumpCollectIncremental()
{
return GarbageCollector.CollectIncremental();
}
// 加载收尾:恢复自动增量模式,再做一次全量阻塞收集清底
public static void FinishLoading()
{
GarbageCollector.GCMode = GarbageCollector.Mode.Incremental;
System.GC.Collect();
}
}
using Unity.Profiling;
using UnityEngine;
// Profiler 验证片段:统计每帧 GC 分配,配合 Timeline 观察 GC.Collect 段
public class GCAllocWatch : MonoBehaviour
{
ProfilerRecorder m_GcAlloc;
void OnEnable()
{
m_GcAlloc = ProfilerRecorder.StartNew(
ProfilerCategory.Memory, "GC Allocated In Frame");
}
void OnDisable() => m_GcAlloc.Dispose();
void Update()
{
// 增量 GC 不改变分配量;这里监控分配是否异常上涨
if (m_GcAlloc.Valid && m_GcAlloc.LastValue > 40 * 1024)
Debug.LogWarning($"GC alloc spike: {m_GcAlloc.LastValue / 1024} KB");
}
}
转载自 CSDN-专业IT技术社区
原文链接:https://blog.csdn.net/chenghai37/article/details/167394211




