1
// ❌ GC Alloc 的常见制造者
2
void Update() {
3
    // 1. 字符串拼接——每次拼接分配新 string
4
    string display = "HP: " + currentHealth + "/" + maxHealth;
5
    // 每帧分配 1 个 string ≈ 40 bytes → 60 FPS = 2.4KB/s
6

7
    // 2. LINQ——背后有迭代器分配
8
    var aliveEnemies = enemies.Where(e => e.IsAlive).ToList();
9
    // Where 分配迭代器 + ToList 分配 List
10

11
    // 3. foreach 在非泛型容器上
12
    foreach (var item in oldArrayList) {}  // 装箱分配
13

14
    // 4. 闭包——每次 lambda 可能分配
15
    button.onClick.AddListener(() => DoSomething(param));
16
    // 捕获 param → 分配闭包对象
17
}

1
// ✅ 修复方案
2
void Update() {
3
    // 1. 用 StringBuilder 或 TMP.SetText 的重载
4
    tmpText.SetText("HP: {0}/{1}", currentHealth, maxHealth);
5

6
    // 2. 不用 LINQ——手写循环
7
    int aliveCount = 0;
8
    for (int i = 0; i < enemies.Count; i++) {
9
        if (enemies[i].IsAlive) aliveCount++;
10
    }
11

12
    // 3. 用泛型容器
13
    foreach (var item in genericList) {}  // 无分配
14

15
    // 4. 缓存委托
16
    button.onClick.AddListener(cachedDoSomething);
17
    // 如果必须传参，用成员变量而非闭包捕获
18
}
19

20
private System.Action cachedDoSomething;
21

22
void Awake() {
23
    cachedDoSomething = DoSomething;
24
}

1
// Profiler 中 Update 耗时 > 2ms 的常见原因：
2

3
// ❌ 1. GetComponent<T>() 在 Update 中
4
void Update() {
5
    var rb = GetComponent<Rigidbody>();
6
    var anim = GetComponent<Animator>();
7
    // GetComponent 约 0.0001ms——但积少成多
8
}
9

10
// ❌ 2. GameObject.Find / FindObjectOfType
11
void Update() {
12
    var manager = FindObjectOfType<GameManager>();  // 遍历整个场景！
13
}
14

15
// ❌ 3. Camera.main
16
void Update() {
17
    var cam = Camera.main;  // 内部是 FindGameObjectWithTag("MainCamera")
18
}
19

20
// ❌ 4. 未缓存的 Transform 访问
21
void Update() {
22
    transform.position += Vector3.forward;
23
    // transform 是 C# 属性——每次访问跨 C++/C# 边界
24
    // 连续访问 10 次 = 10 次跨边界调用
25
}

1
// ✅ 缓存一切
2
public class PlayerOptimized : MonoBehaviour {
3
    private Rigidbody rb;
4
    private Animator animator;
5
    private Camera mainCam;
6
    private Transform cachedTransform;
7

8
    void Awake() {
9
        rb = GetComponent<Rigidbody>();
10
        animator = GetComponent<Animator>();
11
        mainCam = Camera.main;
12
        cachedTransform = transform;
13
    }
14

15
    void Update() {
16
        // 使用缓存引用——零查找开销
17
        cachedTransform.position += Vector3.forward * Time.deltaTime;
18
    }
19
}

1
// ❌ 不需要每帧运行的逻辑也放 Update 里
2
void Update() {
3
    CheckQuestCompletion();  // 任务完成状态——每秒检查一次足够
4
    UpdateMinimap();          // 小地图——每秒 2 次足够
5
    RefreshFriendList();      // 好友列表——10 秒一次足够
6
}
7

8
// ✅ 用定时器降频——协程或计时器
9
[SerializeField] private float questCheckInterval = 1f;
10
private float questCheckTimer;
11

12
void Update() {
13
    questCheckTimer += Time.deltaTime;
14
    if (questCheckTimer >= questCheckInterval) {
15
        CheckQuestCompletion();
16
        questCheckTimer = 0f;
17
    }
18
}
19

20
// 或者用协程
21
IEnumerator SlowUpdate() {
22
    var wait = new WaitForSeconds(1f);
23
    while (true) {
24
        CheckQuestCompletion();
25
        yield return wait;
26
    }
27
}

1
// ============ 1. Static Batching（静态合批）============
2
// 适用：标记为 Static 的、永远不会动的物体
3
// 原理：构建时把多个静态物体的 Mesh 合并为一个超大的 Mesh
4
//       运行时一次 DrawCall 渲染全部
5
// 条件：物体标记为 Batching Static
6
//
7
// 优点：运行时零开销（合并在构建时完成）
8
// 缺点：合并后的 Mesh 占用额外内存（每个物体一份位置数据）
9
//       运行时不能移动物体
10

11
// ============ 2. Dynamic Batching（动态合批）============
12
// 适用：小 Mesh（顶点数 < 300）、同材质的小物体
13
// 原理：运行时每帧尝试合批——CPU 端合并顶点
14
// 条件：同材质 + 顶点属性一致 + 顶点数 < 900（Unity 的限制）
15
//
16
// 优点：不需要标记 Static，物体可以移动
17
// 缺点：每帧 CPU 端合并顶点 → CPU 开销
18
//       顶点限制严苛（大多数 3D 模型不符合条件）
19

20
// ============ 3. GPU Instancing（GPU 实例化）============
21
// 适用：大量相同 Mesh 的物体（树、石头、子弹）
22
// 原理：把"渲染 N 个相同 Mesh"的指令一次发给 GPU
23
//       每个实例可以有不同位置/颜色/缩放（通过 Instance Buffer）
24
// 条件：同 Mesh + 同 Material（Shader 需支持 Instancing）
25
//
26
// 优点：CPU 开销极低（一次 DrawCall 渲染 N 个实例）
27
//       物体可以有不同的 Transform
28
// 缺点：每个实例不能有不同的 Material Property Block（有限支持）
29

30
// ============ 4. SRP Batcher（可编程渲染管线合批）============
31
// 适用：URP/HDRP 项目，同 Shader 但不同材质的物体
32
// 原理：不是合并 Mesh，而是**复用 Shader 的常量缓冲区**
33
//       同 Shader → 材质参数存在 GPU 缓存 → 切换材质零开销
34
// 条件：URP 或 HDRP + Shader 兼容 SRP Batcher
35
//
36
// 优点：比传统 DrawCall 合批灵活得多
37
//       不同材质但同 Shader 也可以高效渲染
38
// 缺点：仅 URP/HDRP——Built-in RP 不支持
39

40
// ============ 选型指南 ============
41
//
42
// Built-in RP（旧项目）：
43
//   静态物体    → Static Batching
44
//   小动态物体  → Dynamic Batching
45
//   大量同类物体 → GPU Instancing
46
//
47
// URP / HDRP（新项目）：
48
//   优先 SRP Batcher（适用性最好）
49
//   大量同 Mesh 物体 → GPU Instancing（与 SRP Batcher 互补）

1
// 场景：一个战斗场景，包含——
2
// 20 棵树（同 Mesh，不同位置/缩放）
3
// 15 块石头（静态）
4
// 地编（多个静态 Mesh 拼接）
5
// 3 个角色 + 武器特效（动态）
6
// UI（独立 Canvas）
7

8
// ============ 优化前（93 DrawCall）============
9
// 树：20（每棵一个 DrawCall——没开 Instancing）
10
// 石头：15（没标记 Static——没合批）
11
// 地编：25（多个 Mesh 拼接——没标记 Static）
12
// 角色 + 武器：3
13
// UI：15（全在一个 Canvas）
14
// 天空盒 + 后处理 + 阴影：15
15

16
// ============ 优化后（4 DrawCall + 15 UI DrawCall）============
17
//
18
// 步骤 1：开启 GPU Instancing
19
//   → 树的 Material 勾选 Enable GPU Instancing
20
//   → 20 棵树 → 1 个 DrawCall
21
//
22
// 步骤 2：标记 Static Batching
23
//   → 石头 + 地编标记 Static
24
//   → 15 + 25 = 40 个物体 → 1 个合并后的 DrawCall
25
//
26
// 步骤 3：UI Canvas 拆分
27
//   → 静态 UI（背景/边框）→ Canvas_Static
28
//   → 动态 UI（血条/计时器）→ Canvas_Dynamic
29
//   → 合批条件改善 + 独立 Canvas 减少重建范围
30
//
31
// 步骤 4：SRP Batcher（如果切到 URP）
32
//   → 剩下的动态物体（角色/武器）——同 Shader 自动合批
33

34
// 最终：4 个主场景 DrawCall + 合理的 UI DrawCall

1
Stack（栈）：
2
  分配：函数调用时自动分配，返回时自动释放
3
  大小：通常 1-2 MB
4
  特点：极快，无 GC，无碎片
5
  内容：值类型（int、float、struct）、局部变量引用
6

7
Heap - Managed（托管堆）：
8
  分配：用 new 关键字，由 GC 自动回收
9
  特点：方便但有 GC 开销
10
  内容：所有 class 实例、string、数组、List<T>
11

12
Heap - Native（原生堆）：
13
  分配：通过 Allocator 手动分配，必须手动释放
14
  特点：无 GC，适合大量数据（纹理、Mesh、音频）
15
  内容：Texture2D、Mesh、AudioClip 的底层数据

1
// ============ 字符串操作 ============
2
// ❌ 每帧分配新 string
3
void Update() {
4
    string msg = "Score: " + score + " / " + maxScore;  // 分配
5
    scoreText.text = msg;
6
}
7

8
// ✅ 只在值变化时更新 + SetText 避免拼接
9
private int lastScore = -1;
10
void Update() {
11
    if (score != lastScore) {
12
        scoreText.SetText("Score: {0} / {1}", score, maxScore);
13
        lastScore = score;
14
    }
15
}
16

17
// ============ LINQ ============
18
// ❌ LINQ 内部有迭代器分配
19
var alive = enemies.Where(e => e.health > 0).OrderBy(e => e.distance).ToList();
20
// 分配：Where 迭代器 + OrderBy 内部结构 + ToList
21

22
// ✅ 手写循环——零分配
23
List<Enemy> aliveList = GetCachedList();  // 复用 List
24
aliveList.Clear();
25
for (int i = 0; i < enemies.Count; i++) {
26
    if (enemies[i].health > 0) {
27
        aliveList.Add(enemies[i]);
28
    }
29
}
30
aliveList.Sort((a, b) => a.distance.CompareTo(b.distance));
31

32
// ============ 装箱 ============
33
// ❌ struct 转 object → 装箱（托管堆分配）
34
int count = 42;
35
object boxed = count;  // 装箱！~24 bytes 分配
36

37
// ❌ 常见装箱场景
38
Debug.Log("Count: " + count);  // + 操作符对 int 用 object → 装箱
39
string.Format("{0}", count);   // object 参数 → 装箱
40

41
// ✅ 避免装箱
42
Debug.Log($"Count: {count}");  // 字符串插值——无装箱
43

44
// ============ 容器扩容 ============
45
// ❌ new List<T>() 默认 capacity = 0
46
// 第一次 Add 扩容到 4 → 第 5 个扩容到 8 → 第 9 个扩容到 16 → ...
47
// 每次扩容 = new T[newSize] + 复制旧数组 → GC Alloc
48

49
// ✅ 预分配容量
50
List<Bullet> bullets = new List<Bullet>(500);  // 提前知道最大值

1
// ============ 纹理压缩 ============
2
// PC：DXT1/DXT5（BC1/BC3）
3
// Android：ASTC 或 ETC2
4
// iOS：ASTC 或 PVRTC
5
//
6
// 未压缩 2048×2048 RGBA = 2048 × 2048 × 4 = 16MB
7
// ASTC 4×4 压缩后 ≈ 2048 × 2048 × 1 = 4MB
8
// 节省 75%
9

10
// Unity 设置：Texture Import Settings → Format → 选择合适的压缩格式
11

12
// ============ 音频压缩 ============
13
// PCM（未压缩）：44100 × 16bit × 2ch = 176KB/s
14
// Vorbis（压缩）：质量 70% ≈ 50KB/s
15
// 节省 70%
16

17
// ============ Resources 文件夹的问题 ============
18
// ❌ Resources 下的所有资源——不管用不用——都打进包
19
// 还都在游戏启动时索引（增加启动时间）
20
//
21
// ✅ 用 Addressables 或 AssetBundle 替代 Resources
22
// 按需加载、按需释放
23

24
// ============ 场景卸载后内存不释放 ============
25
// ❌ LoadScene 切换场景，旧场景的资源还在内存里
26
// ✅ 调用 Resources.UnloadUnusedAssets()——但注意这会触发 GC
27

28
IEnumerator UnloadPreviousScene() {
29
    AsyncOperation op = SceneManager.UnloadSceneAsync(previousScene);
30
    yield return op;
31

32
    // 清理未使用的资源
33
    AsyncOperation unloadOp = Resources.UnloadUnusedAssets();
34
    yield return unloadOp;
35
    // 注意：UnloadUnusedAssets 本身有开销，不要每帧调用
36
}

1
步骤 1：打开 Profiler，展开 CPU Usage → Scripts
2

3
发现：
4
  EnemyUpdate: 6.2ms（30 个敌人 × ~0.2ms）
5
  HealthBarUpdate: 3.1ms（30 个血条，每帧 GetComponent<Slider>() + 字符串拼接）
6
  UIManager.Update: 1.2ms（每帧 FindObjectOfType）
7

8
修复：
9
  1. Enemy.cs——缓存 Transform、Animator、Rigidbody 引用
10
     EnemyUpdate: 6.2ms → 3.5ms
11

12
  2. HealthBar.cs——Awake 缓存 Slider 引用，用 SetText 替代字符串拼接
13
     HealthBarUpdate: 3.1ms → 0.8ms
14

15
  3. UIManager.cs——Awake 时缓存引用，不再每帧 Find
16
     UIManager.Update: 1.2ms → 0.1ms
17

18
第一轮后：CPU 22ms → 14ms，FPS 35 → 55

1
步骤 2：打开 Profiler → Memory → GC Alloc
2

3
发现：
4
  每帧分配 45KB：
5
    - 字符串拼接: 15KB
6
    - LINQ: 12KB
7
    - foreach 装箱: 8KB
8
    - 其它: 10KB
9

10
修复：
11
  1. 所有 Update 中的字符串拼接 → SetText / StringBuilder
12
  2. 替换 LINQ 为手写循环
13
  3. 用泛型 List<T> 替代 ArrayList
14

15
第二轮后：GC Alloc 45KB → 2KB/帧，消除了 GC 卡顿

1
步骤 3：打开 Frame Debugger，逐 DrawCall 分析
2

3
发现：
4
  93 DrawCall：
5
    - 30 个敌人（30 DrawCall）——每个敌人的 Mesh 不同，没法 Instancing
6
    - 15 棵树（15 DrawCall）——没开 Instancing
7
    - 20 块石头（20 DrawCall）——没标 Static
8
    - 15 个头顶血条（15 DrawCall）——没合批
9
    - 13 个其它（天空盒、阴影、后处理）
10

11
修复：
12
  1. 树 → Material 勾选 Enable GPU Instancing
13
     15 DrawCall → 1 DrawCall
14

15
  2. 石头 → 标记 Static Batching
16
     20 DrawCall → 1 DrawCall（合并后）
17

18
  3. 头顶血条 → 独立 Canvas + 图集 + Canvas 拆分
19
     15 DrawCall → 3 DrawCall
20

21
  4. 敌人 → 不需要每帧 Instantiate 特效 → 用粒子对象池
22

23
第三轮后：93 DrawCall → 36 DrawCall