13.2.8 性能优化
所属:全栈开发面试题库 / 13 游戏开发与实时渲染 / 13.2 Unity
覆盖范围
- Unity Profiler
- 合批(Batching)
- GC Alloc 与内存
- IL2CPP
- 移动端发热与功耗
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 13.2.8-001 | Profiler 看到 GC.Alloc 频繁怎么排查? | 进阶 | ★★★★★ |
| 13.2.8-002 | Draw Call 多怎么优化? | 基础 | ★★★★★ |
| 13.2.8-003 | IL2CPP 和 Mono 的区别? | 进阶 | ★★★★ |
| 13.2.8-004 | 移动端发热严重怎么排查? | 进阶 | ★★★★ |
| 13.2.8-005 | GC 是什么?怎么减少 GC? | 基础 | ★★★★ |
| 13.2.8-006 | Static Batching 和 Dynamic Batching 怎么选? | 进阶 | ★★★ |
| 13.2.8-007 | 内存泄漏怎么排查? | 进阶 | ★★★★ |
| 13.2.8-008 | 帧率不稳定怎么优化? | 进阶 | ★★★ |
13.2.8-001 Profiler 看到 GC.Alloc 频繁怎么排查?
一句话结论
GC.Alloc 表示每帧分配内存导致 GC 频繁触发;排查方向:查找 Update 里的字符串拼接、LINQ、装箱、临时数组。
概念解释
- GC.Alloc:托管堆分配,触发垃圾回收。
- 频繁 GC:每帧分配导致 GC 频繁,帧率下降。
- 常见原因:Update 里字符串拼接、LINQ、装箱、临时数组。
- Profiler:Unity Profiler 的 Memory Module 看 GC.Alloc。
原理流程
- Profiler 看 GC.Alloc 峰值。
- 定位:在 Update 里找字符串拼接、LINQ、临时数组。
- 修复:缓存字符串、用 StringBuilder、复用数组。
代码或图示
// 错误:每帧分配
void Update() {
string s = "HP: " + hp; // 字符串拼接 GC.Alloc
int[] arr = new int[100]; // 临时数组 GC.Alloc
}
// 正确:缓存
private StringBuilder sb = new StringBuilder();
void Update() {
sb.Clear();
sb.Append("HP: ").Append(hp); // 不分配
}
常见误区
- 误区:GC.Alloc 一定是问题;正解:少量 GC.Alloc 没关系;频繁 GC.Alloc(每帧几 KB)才是问题。
- 误区:字符串拼接总是 GC;正解:常量字符串拼接编译期优化;变量拼接才 GC。
追问
- 什么是 Boxing(装箱)?答:值类型转 object 引用类型,堆分配;频繁装箱导致 GC。
- 怎么避免装箱?答:用泛型(List
)而不是 ArrayList,用 int 而不是 object。
13.2.8-002 Draw Call 多怎么优化?
一句话结论
Draw Call 多:合批(Static/Dynamic/GPU Instancing)、减少材质切换、减少渲染对象;目标移动端 100-200 次 Draw Call。
概念解释
- Draw Call:CPU 提交渲染命令。
- 合批:相同材质的物体合并成一个 Draw Call。
- Static Batching:静态物体合并。
- Dynamic Batching:小顶点物体动态合并。
- GPU Instancing:相同网格和材质实例化。
原理流程
- 合批:相同材质的物体合并。
- 减少材质:不同材质 = 不同 Draw Call;共享材质。
- 减少对象:远处物体用 LOD 或 Billboard。
代码或图示
优化:
100 棵树 → Static Batching → 1 个 Draw Call
100 个敌人(相同材质)→ GPU Instancing → 1 个 Draw Call
远处物体 → LOD → 三角形减少
常见误区
- 误区:Draw Call 越少越好;正解:合批增加顶点数据,过度合批 GPU 慢;移动端 100-200 次合理。
- 误区:所有物体都能合批;正解:不同材质、不同渲染队列、透明物体不能合批。
追问
- 什么是 SetPass Call?答:材质切换次数,比 Draw Call 更准确;不同材质 = 不同 SetPass。
- 什么是 SRP Batcher?答:SRP 的优化,相同 Shader 不同材质合批,比 Dynamic Batching 快。
13.2.8-003 IL2CPP 和 Mono 的区别?
一句话结论
Mono 是 JIT 编译(运行时编译),IL2CPP 把 C# 转成 C++ 再编译为本机码;IL2CPP 性能好、包体小、防篡改,但失去 JIT 热更能力。
概念解释
- Mono:JIT 运行时编译,启动快,跨平台,但性能差。
- IL2CPP:AOT(Ahead of Time)编译,C# 转 C++ 再编译本机码,性能好,包体小。
- JIT:运行时编译,支持热更。
- AOT:提前编译,不支持热更。
原理流程
- Mono:C# IL → JIT 编译本机码,运行时执行。
- IL2CPP:C# IL → C++ → 编译本机码,启动快。
- 热更:Mono 支持 JIT 热更,IL2CPP 不支持(要 HybridCLR)。
代码或图示
Mono:
C# IL → JIT 编译 → 本机码
优点:热更、启动快
缺点:性能差
IL2CPP:
C# IL → C++ → 编译 → 本机码
优点:性能好、包体小
缺点:不支持热更
常见误区
- 误区:IL2CPP 一定比 Mono 快;正解:IL2CPP 性能好,但启动慢(编译时间);小项目 Mono 够。
- 误区:IL2CPP 不能热更;正解:IL2CPP 不支持 JIT 热更,但 HybridCLR 可以实现 C# 热更。
追问
- 什么是 HybridCLR?答:在 IL2CPP 上实现 C# 热更的方案,加载动态编译的 dll。
- 什么是 AOT?答:Ahead of Time,提前编译,运行时不需要 JIT。
13.2.8-004 移动端发热严重怎么排查?
一句话结论
移动端发热是 CPU/GPU 负载高导致功耗大;排查方向:CPU 占用(逻辑、GC)、GPU 占用(渲染、Draw Call)、帧率过高。
概念解释
- 发热原因:CPU/GPU 持续高负载,功耗大,设备发热。
- CPU 负载:逻辑、物理、GC、脚本。
- GPU 负载:渲染、Draw Call、Overdraw、纹理带宽。
- 帧率:高帧率(60fps)比低帧率(30fps)功耗大。
原理流程
- Profiler 看 CPU/GPU 时间。
- CPU 高:优化逻辑、减少 GC、减少物理。
- GPU 高:减少 Draw Call、降低 Render Scale、减少 Overdraw。
- 帧率:限制 30fps 或动态帧率。
代码或图示
发热排查:
CPU 高 → 优化逻辑、减少 GC、减少物理
GPU 高 → 减少 Draw Call、降低 Render Scale、减少 Overdraw
帧率高 → 限制 30fps 或动态帧率
常见误区
- 误区:发热是手机问题;正解:发热是游戏负载高,优化游戏可以解决。
- 误区:锁 60fps 体验好;正解:60fps 功耗大;30fps 更省电,或动态帧率。
追问
- 什么是 Thermal Throttling?答:手机过热后降频,帧率下降;要在发热前优化。
- 什么是 Dynamic Resolution?答:动态分辨率,负载高时降低渲染分辨率,保持帧率。
13.2.8-005 GC 是什么?怎么减少 GC?
一句话结论
GC(垃圾回收)自动回收不再使用的内存;频繁 GC 导致帧率下降;减少 GC:减少堆分配、缓存对象、复用数组。
概念解释
- GC:垃圾回收,自动回收堆中不再使用的对象。
- 频繁 GC:每帧分配导致 GC 频繁,帧率下降。
- 减少分配:缓存对象、复用数组、避免字符串拼接。
- 对象池:频繁创建销毁的对象用对象池复用。
原理流程
- 分配:new 对象在堆上分配。
- GC:堆满时触发 GC,遍历所有对象,回收未引用的。
- 减少:复用对象,减少分配。
代码或图示
// 错误:每帧 new
void Update() {
GameObject go = new GameObject(); // 堆分配
}
// 正确:对象池
private Stack<GameObject> pool = new Stack<GameObject>();
void Spawn() {
GameObject go = pool.Count > 0 ? pool.Pop() : new GameObject();
}
void Despawn(GameObject go) {
pool.Push(go);
}
常见误区
- 误区:GC 是好的;正解:GC 自动回收但频繁 GC 卡帧;要减少分配。
- 误区:栈对象不 GC;正解:栈对象方法结束自动释放;堆对象才 GC。
追问
- 什么是 Generation?答:GC 分代(Gen0/1/2),新对象 Gen0,存活久的 Gen1/2;Gen0 GC 快,Gen2 GC 慢。
- 什么是 Object Pool?答:对象池,预创建对象,复用不销毁;频繁创建的对象用池。
13.2.8-006 Static Batching 和 Dynamic Batching 怎么选?
一句话结论
Static Batching 适合不能移动的静态物体(建筑、地形),Dynamic Batching 适合小顶点动态物体;大模型和移动物体不合批。
概念解释
- Static Batching:静态物体合并,运行时一次 Draw Call,但不能移动。
- Dynamic Batching:小顶点(< 300)物体动态合并,适合移动。
- GPU Instancing:相同网格和材质实例化。
原理流程
- 静态物体:建筑、地形,标记 Static,Static Batching 合并。
- 小动态物体:子弹、小道具,Dynamic Batching。
- 大模型:角色、车辆,不适合合批。
代码或图示
Static Batching:建筑、地形(不能移动)
Dynamic Batching:小道具(< 300 顶点)
GPU Instancing:相同网格(树木、敌人)
常见误区
- 误区:Static Batching 节省内存;正解:Static Batching 复制顶点到合并缓冲,内存增加。
- 误区:Dynamic Batching 适合所有物体;正解:限制 300 顶点,大模型不合批。
追问
- 什么是 Batching Break?答:合批失败的原因(材质不同、渲染队列不同)。
- 什么是 GPU Instancing?答:相同网格和材质,用 instance buffer 一次 Draw Call 画多个实例。
13.2.8-007 内存泄漏怎么排查?
一句话结论
内存泄漏:对象不再使用但没被 GC,内存持续增长;排查方向:事件订阅、静态引用、缓存未清理。
概念解释
- 内存泄漏:对象不再使用但被引用,GC 无法回收。
- 常见原因:事件订阅未取消、静态引用、缓存未清理。
- Profiler:Unity Memory Profiler 看对象分布。
- 修复:取消订阅、清理缓存、弱引用。
原理流程
- Profiler 看内存持续增长。
- 定位:事件订阅未取消、静态引用。
- 修复:OnDisable 取消订阅、清理缓存。
代码或图示
// 泄漏:事件订阅未取消
void OnEnable() {
Player.OnDeath += HandleDeath; // 订阅
}
// 忘记 OnDisable 取消订阅 → Player 持有 UI 引用 → UI 不回收
// 修复
void OnDisable() {
Player.OnDeath -= HandleDeath; // 取消订阅
}
常见误区
- 误区:C# 有 GC 就不会泄漏;正解:GC 只回收未引用的;事件订阅和静态引用导致泄漏。
- 误区:内存增长就是泄漏;正解:内存增长可能是正常缓存;持续增长才是泄漏。
追问
- 什么是 Memory Profiler?答:Unity 的内存分析工具,看对象分布和引用链。
- 什么是 Weak Reference?答:弱引用,不阻止 GC;缓存用弱引用避免泄漏。
13.2.8-008 帧率不稳定怎么优化?
一句话结论
帧率不稳定:某些帧耗时突增(GC、加载、实例化);优化方向:减少峰值、预加载、对象池。
概念解释
- 帧率不稳定:某些帧 16ms(60fps),某些帧 50ms(20fps)。
- 原因:GC、加载、实例化、物理。
- 优化:减少峰值、预加载、对象池。
- 目标:帧率稳定 30 或 60fps。
原理流程
- Profiler 看帧时间分布,找峰值帧。
- 峰值原因:GC、实例化、加载。
- 优化:对象池、预加载、分帧处理。
代码或图示
帧率不稳定:
正常帧 16ms
峰值帧 50ms(GC/实例化/加载)
优化:
对象池 → 减少实例化峰值
预加载 → 减少加载峰值
分帧处理 → 把大任务分到多帧
常见误区
- 误区:平均帧率够就行;正解:玩家感知的是帧率波动,不是平均;稳定 30fps 比波动 60fps 好。
- 误区:帧率不稳定是 GPU 问题;正解:可能是 CPU(GC、逻辑),不一定是 GPU。
追问
- 什么是 Frame Time?答:每帧耗时,16ms = 60fps,33ms = 30fps。
- 什么是 Preloading?答:预加载下一关卡资源,避免加载时卡顿。
13.2.8-009 IL2CPP 和 Mono 的区别?
一句话结论
Mono 是 JIT 编译,运行时编译 IL 到机器码,启动快但运行慢;IL2CPP 是 AOT 编译,构建时编译 IL 到 C++,运行快但构建慢。
概念解释
- Mono:JIT(Just-In-Time),运行时编译。
- IL2CPP:AOT(Ahead-Of-Time),构建时编译。
- IL2CPP 运行快、包小、防反编译;Mono 启动快、调试方便。
原理流程
- Mono:构建出 DLL,运行时 JIT 编译。
- IL2CPP:构建时把 IL 转 C++,再编译成机器码。
- 运行时:IL2CPP 直接执行机器码,Mono 运行时编译。
代码或图示
Mono:
DLL → 运行时 JIT → 机器码
启动快,运行慢,包大
IL2CPP:
IL → C++ → 机器码(构建时)
运行快,包小,防反编译
常见误区
- 误区:IL2CPP 性能一定好;正解:IL2CPP 启动慢(AOT),但运行快。
- 误区:IL2CPP 不能调试;正解:IL2CPP 可以调试,但流程复杂。
追问
- 什么是 JIT?答:运行时编译。
- 什么是 AOT?答:构建时编译。
待整理清单
- [ ] Unity 最新版本 Profiler 变化
- [ ] VContainer/Zenject 在大型项目的性能
- [ ] 移动端功耗优化最佳实践