4.5 内存管理 (Memory Management) (对象池, 资源卸载)

4.5 内存管理 (Memory Management) (对象池, 资源卸载)

4.5 内存管理 (Memory Management)

4.5.1 内存管理的重要性

在游戏运行过程中，会不断地创建和销毁各种游戏对象和资源，例如角色、敌人、特效、UI 元素、纹理、模型、音频等。如果不对这些内存操作进行有效管理，很容易导致以下问题：

• 性能下降 (Performance Degradation): 频繁的内存分配和释放 (尤其是在帧更新循环中) 会产生大量的垃圾 (Garbage)。Unity 的垃圾回收器 (Garbage Collector, GC) 需要定期清理这些垃圾，GC 的运行会暂停游戏主线程，导致帧率下降，出现卡顿现象。

• 内存泄漏 (Memory Leak): 如果对象被创建后，在不再使用时没有被正确释放，就会造成内存泄漏。长期累积的内存泄漏会耗尽可用内存，最终导致游戏崩溃。

• 加载时间过长 (Long Loading Times): 不合理的资源加载方式会增加游戏的启动时间和场景切换时间，影响用户体验。

• 构建包体积过大 (Large Build Size): 项目中包含过多冗余或未优化的资源，会导致最终构建的游戏包体积过大，不利于发布和下载。

因此，理解和掌握 Unity 的内存管理机制，并采取有效的策略来优化内存使用，是每个 Unity 开发者必须掌握的技能。

4.5.2 对象池 (Object Pooling)

4.5.2.1 什么是对象池？

对象池是一种软件设计模式，旨在复用对象，而不是频繁地创建和销毁对象。 在游戏中，很多对象是需要频繁创建和销毁的，例如子弹、特效粒子、敌人等。传统的做法是每次需要时都 Instantiate 创建，不再使用时 Destroy 销毁。然而，Instantiate 和 Destroy 操作涉及到内存的分配和释放，在高频率调用时会产生显著的性能开销，并增加 GC 的压力。

对象池的核心思想是预先创建一批对象，将它们存储在一个“池子”中。当需要使用对象时，从池子中“取出”一个已经存在的对象，使用完毕后，再将对象“放回”池子，而不是销毁它。下次需要同类型对象时，直接从池子中取用，避免了重复的创建和销毁过程。

4.5.2.2 为什么使用对象池？

使用对象池的主要优势在于：

• 减少内存分配和释放开销: 对象池通过复用对象，显著减少了 Instantiate 和 Destroy 的调用次数，从而降低了内存分配和释放的频率，减少了 GC 的压力。

• 提升性能: 避免了频繁的内存操作，减少了 GC 造成的卡顿，提升了游戏的整体运行性能，尤其是在需要大量生成和销毁对象的场景中效果显著。

• 更平滑的帧率: 减少了 GC 的不确定性影响，使帧率更加稳定，游戏体验更流畅。

4.5.2.3 对象池的实现 (代码实践)

下面是一个简单的对象池的 C# 代码实现示例，可以用于管理 GameObject 对象。

using System.Collections.Generic;
using UnityEngine;
public class GameObjectPool
{
    private GameObject prefab; // 对象池管理的预制体
    private List<GameObject> pool; // 对象池列表
    private Transform poolParent; // 对象池父物体，用于组织层级
    public GameObjectPool(GameObject prefab, int initialSize, Transform parent = null)
    {
        this.prefab = prefab;
        pool = new List<GameObject>();
        poolParent = parent != null ? parent : new GameObject($"{prefab.name} Pool").transform;
        InitializePool(initialSize);
    }
    // 初始化对象池
    private void InitializePool(int size)
    {
        for (int i = 0; i < size; i++)
        {
            GameObject obj = CreateNewObject();
            pool.Add(obj);
        }
    }
    // 创建新的对象并放入池中
    private GameObject CreateNewObject()
    {
        GameObject obj = GameObject.Instantiate(prefab);
        obj.SetActive(false); // 初始状态设置为非激活
        obj.transform.SetParent(poolParent); // 设置父物体，方便管理
        return obj;
    }
    // 从对象池中获取对象
    public GameObject GetObject()
    {
        GameObject obj;
        if (pool.Count > 0)
        {
            obj = pool[0];
            pool.RemoveAt(0);
            obj.SetActive(true); // 获取时激活
        }
        else
        {
            // 对象池为空时，创建新的对象 (可以根据需求选择扩展池子或返回 null)
            obj = CreateNewObject();
            obj.SetActive(true); // 获取时激活
        }
        return obj;
    }
    // 将对象返回对象池
    public void ReturnObject(GameObject obj)
    {
        if (obj == null) return; // 防止空引用
        obj.SetActive(false); // 返回时设置为非激活
        obj.transform.SetParent(poolParent); // 重新设置父物体，保持层级整洁
        pool.Add(obj);
    }
    // 清空对象池 (可选)
    public void ClearPool()
    {
        foreach (var obj in pool)
        {
            GameObject.Destroy(obj); // 真正销毁对象
        }
        pool.Clear();
    }
    // 获取对象池当前大小
    public int PoolSize => pool.Count;
}
​

代码详解:

1. GameObjectPool 类: 封装了对象池的逻辑。

2. prefab: 存储要池化的预制体 GameObject。

3. pool: List<GameObject> 类型的列表，用于存储池中的对象。

4. poolParent: Transform 类型，用于设置池中对象的父物体，方便在层级视图中组织和管理对象池。

5. 构造函数 GameObjectPool(GameObject prefab, int initialSize, Transform parent = null):

   • 接收预制体 prefab、初始池大小 initialSize 和可选的父物体 parent 作为参数。

   • 初始化 prefab、pool 和 poolParent。

   • 调用 InitializePool(initialSize) 初始化对象池。

6. InitializePool(int size):

   • 循环创建 size 个对象，并添加到 pool 中。

7. CreateNewObject():

   • 使用 GameObject.Instantiate(prefab) 创建新的对象实例。

   • 设置对象为非激活状态 (obj.SetActive(false))，避免在初始化时立即显示。

   • 设置对象的父物体为 poolParent，方便管理。

   • 返回创建的对象。

8. GetObject():

   • 尝试从 pool 列表中取出第一个对象。

   • 如果 pool 不为空，取出对象，从 pool 中移除，并激活对象 (obj.SetActive(true))。

   • 如果 pool 为空 (池中没有可用对象)，则调用 CreateNewObject() 创建新的对象，并激活。 (可以根据实际需求选择是否扩展池子，或者返回 null 表示池中没有可用对象)。

   • 返回获取的对象。

9. ReturnObject(GameObject obj):

   • 接收要返回池中的对象 obj 作为参数。

   • 检查 obj 是否为空，防止空引用错误。

   • 设置对象为非激活状态 (obj.SetActive(false))。

   • 设置对象的父物体为 poolParent。

   • 将对象添加回 pool 列表的末尾。

10. ClearPool() (可选):

    • 遍历 pool 列表，使用 GameObject.Destroy(obj) 真正销毁池中的所有对象，并清空 pool 列表。 这个方法通常在场景卸载或者需要彻底清理对象池时使用。

11. PoolSize 属性:

    • 提供只读属性 PoolSize，返回当前对象池中可用对象的数量。

使用示例:

public class ObjectPoolExample : MonoBehaviour
{
    public GameObject bulletPrefab; // 子弹预制体
    private GameObjectPool bulletPool;
    void Start()
    {
        // 创建子弹对象池，初始大小为 20
        bulletPool = new GameObjectPool(bulletPrefab, 20, transform);
    }
    void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            // 从对象池获取子弹
            GameObject bullet = bulletPool.GetObject();
            if (bullet != null)
            {
                bullet.transform.position = transform.position; // 设置子弹位置
                bullet.transform.rotation = transform.rotation; // 设置子弹旋转
                bullet.GetComponent<Rigidbody>().velocity = transform.forward * 10f; // 给子弹施加力
                // 一段时间后将子弹返回对象池 (可以使用协程或者其他方式管理对象生命周期)
                StartCoroutine(ReturnBulletToPool(bullet, 2f));
            }
        }
    }
    IEnumerator ReturnBulletToPool(GameObject bullet, float delay)
    {
        yield return new WaitForSeconds(delay);
        bulletPool.ReturnObject(bullet); // 将子弹返回对象池
    }
}
​

使用步骤:

1. 创建预制体: 准备好需要池化的对象的预制体 (例如子弹预制体 bulletPrefab)。

2. 创建对象池实例: 在脚本中创建 GameObjectPool 的实例，传入预制体、初始大小和可选的父物体。

3. 获取对象: 需要使用对象时，调用 bulletPool.GetObject() 从对象池中获取。

4. 使用对象: 对获取的对象进行初始化和使用 (例如设置位置、旋转、速度等)。

5. 返回对象: 对象使用完毕后，调用 bulletPool.ReturnObject(bullet) 将对象返回对象池。

4.5.2.4 何时使用对象池？

对象池适用于以下场景：

• 频繁创建和销毁的对象: 例如子弹、导弹、敌人、特效粒子、UI 元素 (例如列表中的 Item) 等。

• 生命周期短的对象: 对象的使用时间相对较短，但创建频率很高。

• 性能敏感的场景: 需要优化性能，减少 GC 压力，提升帧率的场景。

不适用对象池的场景:

• 创建频率低的对象: 如果对象的创建频率很低，甚至只创建一次，对象池的收益可能不大，甚至会增加代码的复杂性。

• 生命周期长的对象: 如果对象的生命周期很长，几乎贯穿整个游戏过程，那么对象池的意义不大。

• 对象差异性大的对象: 如果需要池化的对象之间差异性很大，例如需要根据不同参数创建不同类型的对象，对象池的通用性会降低。

4.5.2.5 对象池的优点和缺点

优点:

• 显著提升性能: 减少内存分配和释放，降低 GC 压力，提升帧率。

• 更平滑的游戏体验: 减少卡顿，提供更稳定的帧率。

• 代码结构更清晰: 将对象的创建和销毁逻辑集中管理，使代码更易于维护。

缺点:

• 增加代码复杂度: 需要编写和维护对象池的管理代码，增加了一定的代码复杂度。

• 预加载开销: 对象池在初始化时需要预先创建一批对象，可能会增加初始加载时间。

• 内存占用: 对象池会预先占用一定的内存，即使在不需要使用对象时也占用着。需要合理设置对象池的初始大小和最大容量，避免过度占用内存。

4.5.2.6 Mermaid 图表示例

图表解释:

• 游戏场景: 游戏运行的场景。

• 需要对象: 游戏中需要创建某种类型的对象 (例如子弹)。

• 对象池: 预先创建并管理对象的池子。

• 对象池是否有可用对象: 判断对象池中是否有空闲的对象可以使用。

• 从对象池获取对象: 如果对象池中有可用对象，则直接从池中取出。

• 创建新对象并加入对象池: 如果对象池为空，则创建一个新的对象，并将其加入对象池 (可选的池子扩展机制)。

• 使用对象: 获取对象后，进行初始化和使用。

• 对象使用完毕: 对象完成任务，不再需要使用。

• 将对象返回对象池: 将使用完毕的对象返回对象池，以便下次复用。

• 正常创建对象: 在没有对象池的情况下，每次需要对象都进行创建。

• 正常销毁对象: 在没有对象池的情况下，对象不再使用时进行销毁。

4.5.3 资源卸载 (Resource Unloading)

4.5.3.1 什么是资源卸载？

在 Unity 中，资源 (Assets) 包括纹理 (Textures)、模型 (Models)、音频剪辑 (Audio Clips)、材质 (Materials)、场景 (Scenes) 等。当游戏加载并使用这些资源时，它们会被加载到内存中。如果不进行有效的资源管理，内存占用会不断增加，最终可能导致内存溢出或性能下降。

资源卸载 (Resource Unloading) 指的是将不再使用的资源从内存中释放出来，从而降低内存占用，提升游戏性能。 Unity 提供了多种资源卸载的方法，开发者需要根据不同的资源类型和使用场景选择合适的卸载策略。

4.5.3.2 为什么资源卸载是必要的？

资源卸载的必要性体现在以下几个方面：

• 限制内存占用: 游戏运行的设备通常有内存限制，尤其是在移动平台。资源卸载可以有效控制内存占用，防止内存溢出导致游戏崩溃。

• 提升性能: 降低内存压力，减少因内存不足导致的性能下降，提升游戏的运行效率。

• 优化加载时间: 及时卸载不再需要的资源，可以加快后续场景或资源的加载速度。

• 减小构建包体积: 虽然资源卸载主要是在运行时进行内存管理，但合理的资源管理策略也有助于减少项目中冗余资源，间接减小最终构建的游戏包体积。

4.5.3.3 资源类型和卸载方法

Unity 中常见的资源类型和对应的卸载方法主要有以下几种：

1. 场景 (Scenes):

• 卸载方法: 使用 SceneManager.UnloadSceneAsync 或 SceneManager.UnloadScene 卸载不再需要的场景。

• 场景卸载的特点: 卸载场景会释放场景中包含的所有资源，包括 GameObject、组件、以及场景中引用的其他资源。

• 代码示例:

using UnityEngine;
using UnityEngine.SceneManagement;
using System.Collections;
public class SceneUnloadExample : MonoBehaviour
{
    public string sceneToUnloadName = "SceneToUnload";
    public void UnloadScene()
    {
        StartCoroutine(UnloadSceneAsyncCoroutine());
    }
    IEnumerator UnloadSceneAsyncCoroutine()
    {
        AsyncOperation asyncUnload = SceneManager.UnloadSceneAsync(sceneToUnloadName);
        while (!asyncUnload.isDone)
        {
            Debug.Log($"卸载场景进度: {asyncUnload.progress}");
            yield return null;
        }
        Debug.Log($"场景 {sceneToUnloadName} 卸载完成");
    }
}
​

2. 未使用的资源 (Unused Assets):

• 卸载方法: 使用 Resources.UnloadUnusedAssets() 卸载当前场景中不再被任何对象引用的资源。

• Resources.UnloadUnusedAssets() 的特点:

  • 非立即卸载: Resources.UnloadUnusedAssets() 不是立即执行的，它会在下一帧结束时进行异步卸载。

  • 卸载条件: 只有当资源不再被场景中的任何 GameObject 或其他资源引用时，才会被卸载。

  • 注意事项: 过度频繁调用 Resources.UnloadUnusedAssets() 可能会导致性能抖动，建议在场景切换、关卡结束等时机调用。

• 代码示例:

using UnityEngine;
public class UnloadUnusedAssetsExample : MonoBehaviour
{
    public void UnloadUnused()
    {
        StartCoroutine(UnloadUnusedAssetsCoroutine());
    }
    IEnumerator UnloadUnusedAssetsCoroutine()
    {
        AsyncOperation asyncUnload = Resources.UnloadUnusedAssets();
        while (!asyncUnload.isDone)
        {
            Debug.Log($"卸载未使用资源进度: {asyncUnload.progress}");
            yield return null;
        }
        Debug.Log("未使用资源卸载完成");
    }
}
​

3. AssetBundle 资源:

• 卸载方法: 使用 AssetBundle.Unload(bool unloadAllLoadedObjects) 卸载 AssetBundle 加载的资源。

• AssetBundle.Unload(bool unloadAllLoadedObjects) 的特点:

  • unloadAllLoadedObjects 参数:

    • true: 卸载 AssetBundle 以及所有从该 AssetBundle 加载的 GameObject 和其他资源。如果这些资源在场景中被引用，引用会变成丢失状态 (missing)。

    • false: 只卸载 AssetBundle 本身，不卸载从该 AssetBundle 加载的 GameObject 和资源。如果场景中仍然引用了这些资源，它们仍然会存在于内存中。

  • 适用场景: AssetBundle 通常用于加载和卸载模块化的游戏内容，例如 DLC、关卡资源等。

• 代码示例:

using UnityEngine;
using UnityEngine.Networking;
using System.Collections;
public class AssetBundleUnloadExample : MonoBehaviour
{
    public string assetBundleURL = "http://www.example.com/myassetbundle";
    private AssetBundle loadedAssetBundle;
    public void LoadAndUnloadAssetBundle()
    {
        StartCoroutine(LoadAssetBundleCoroutine());
    }
    IEnumerator LoadAssetBundleCoroutine()
    {
        UnityWebRequest www = UnityWebRequestAssetBundle.GetAssetBundle(assetBundleURL);
        yield return www.SendWebRequest();
        if (www.result == UnityWebRequest.Result.ConnectionError || www.result == UnityWebRequest.Result.ProtocolError)
        {
            Debug.LogError($"AssetBundle 下载失败: {www.error}");
            yield break;
        }
        loadedAssetBundle = DownloadHandlerAssetBundle.GetContent(www);
        if (loadedAssetBundle != null)
        {
            Debug.Log("AssetBundle 加载成功");
            // ... 使用 AssetBundle 中的资源 ...
            // 卸载 AssetBundle (unloadAllLoadedObjects 参数根据需求选择)
            UnloadAssetBundle(true);
        }
    }
    public void UnloadAssetBundle(bool unloadAllLoadedObjects)
    {
        if (loadedAssetBundle != null)
        {
            loadedAssetBundle.Unload(unloadAllLoadedObjects);
            loadedAssetBundle = null;
            Debug.Log($"AssetBundle 卸载完成 (unloadAllLoadedObjects: {unloadAllLoadedObjects})");
        }
    }
}
​

4. 手动管理资源引用 (降低资源常驻内存的可能):

• 策略: 避免在脚本中长时间持有对大型资源的引用。当资源不再需要使用时，及时将引用置为 null，让垃圾回收器有机会回收这些资源。

• 适用场景: 适用于纹理、模型、音频等大型资源。

• 代码示例:

using UnityEngine;
using UnityEngine.UI;
public class TextureUnloadExample : MonoBehaviour
{
    public RawImage rawImage;
    private Texture2D loadedTexture;
    public void LoadTexture()
    {
        loadedTexture = Resources.Load<Texture2D>("MyTexture"); // 加载纹理
        rawImage.texture = loadedTexture; // 应用纹理
    }
    public void UnloadTexture()
    {
        rawImage.texture = null; // 移除 RawImage 的纹理引用
        loadedTexture = null; // 将脚本中的纹理引用置空
        Resources.UnloadUnusedAssets(); // 触发未使用资源卸载
    }
}
​

4.5.3.4 何时卸载资源？

资源卸载的时机需要根据游戏的具体情况进行权衡，以下是一些常见的卸载时机：

• 场景切换: 当场景切换时，可以卸载上一个场景中不再需要的资源。

• 关卡结束/开始: 在关卡开始前加载关卡所需的资源，关卡结束后卸载关卡资源。

• 模块功能切换: 例如在 RPG 游戏中，切换到不同的游戏模块 (例如战斗场景、城镇场景) 时，可以卸载之前模块的资源。

• 内存压力过高时: 当游戏运行时检测到内存占用过高时，可以主动触发资源卸载操作。

• 资源不再需要使用时: 例如当一个 UI 界面关闭后，可以卸载该界面使用的纹理、图集等资源。

卸载策略建议:

• 场景卸载优先: 对于不再需要的场景，优先使用 SceneManager.UnloadSceneAsync 卸载整个场景。

• 按需加载和卸载: 只加载当前需要的资源，并在不需要时及时卸载。

• 避免频繁卸载和加载: 频繁的资源卸载和加载也会带来性能开销，需要权衡卸载的频率。

• 使用 Profiler 监控内存: 使用 Unity Profiler 的 Memory 模块监控内存使用情况，找出内存瓶颈，并根据 Profiler 的数据调整资源卸载策略。

4.5.3.5 资源卸载的优点和缺点

优点:

• 降低内存占用: 有效减少游戏运行时的内存消耗。

• 提升性能: 降低内存压力，减少性能抖动，提升帧率。

• 优化加载速度: 加快后续场景和资源的加载速度。

• 防止内存溢出: 降低游戏崩溃的风险。

缺点:

• 增加开发复杂度: 需要开发者手动管理资源的加载和卸载，增加了开发工作量。

• 卸载和加载的性能开销: 资源卸载和重新加载本身也需要一定的性能开销。

• 资源丢失风险: 不正确的资源卸载可能会导致场景中使用的资源丢失，需要谨慎管理资源引用。

4.5.3.6 Mermaid 图表示例

图表解释:

• 游戏运行: 游戏持续运行。

• 内存监控: 持续监控游戏的内存占用情况。

• 内存占用高: 当内存占用超过预设阈值时，触发资源卸载策略。

• 内存占用正常: 内存占用在合理范围内，游戏继续正常运行。

• 资源卸载策略: 根据不同的触发条件，选择不同的资源卸载方法。

• 场景切换: 发生场景切换时。

• 关卡结束: 当前关卡结束时。

• 模块切换: 游戏模块发生切换时。

• 资源不再使用: 检测到某些资源不再被场景引用时。

• 卸载场景: 使用 SceneManager.UnloadSceneAsync 卸载场景。

• 卸载关卡资源: 卸载关卡相关的资源 (例如使用 AssetBundle 加载的关卡资源)。

• 卸载模块资源: 卸载当前模块不再需要的资源。

• 卸载未使用资源: 使用 Resources.UnloadUnusedAssets() 卸载未使用资源。

• 继续运行: 资源卸载完成后，游戏继续运行。

4.5.4 内存管理最佳实践

除了对象池和资源卸载，以下是一些 Unity 内存管理的最佳实践：

1. 使用 Profiler 进行内存分析: 熟练使用 Unity Profiler 的 Memory 模块，分析内存分配、GC 情况、资源占用等，找出内存瓶颈，并针对性地进行优化。

2. 优化资源本身:

   • 纹理压缩: 使用合适的纹理压缩格式 (例如 ETC2, ASTC, PVRTC)，减小纹理内存占用。

   • 模型优化: 减少模型面数，使用 LOD 技术 (Level of Detail) 降低远距离模型的复杂度。

   • 音频压缩: 使用合适的音频压缩格式 (例如 Vorbis, MP3)，减小音频文件大小。

   • 图集 (Texture Atlas) 和 Sprite Sheet: 将多个小纹理合并成图集，减少 Draw Call 和纹理切换，提高渲染效率，并减少纹理数量。

3. 避免不必要的内存分配:

   • 字符串拼接: 避免在循环中频繁使用 + 或 += 进行字符串拼接，使用 StringBuilder 替代。

   • 装箱拆箱: 避免值类型和引用类型之间的频繁转换，减少装箱拆箱操作。

   • LINQ 和 foreach: 在性能敏感的代码段，谨慎使用 LINQ 和 foreach，它们可能会产生额外的内存分配。

   • 避免在 Update() 中创建对象: 尽量避免在 Update() 函数等帧更新循环中创建新的对象，将对象的创建操作移到初始化阶段或使用对象池。

4. 合理使用 Resources 文件夹: Resources.Load 加载的资源会被打包到最终构建包中，即使在游戏中没有被使用，也会增加包体积和内存占用。谨慎使用 Resources 文件夹，尽可能使用 AssetBundle 或 Addressable Asset System 等更灵活的资源管理方案。

5. 使用 Addressable Asset System: Unity 的 Addressable Asset System 提供了更高级的资源管理功能，包括异步加载、资源依赖管理、远程资源加载、内容更新等，可以更有效地管理和优化资源。