Unity进阶---对象池/缓存池_unity 对象池

作者：木道寻08 | 2024-08-21 08:46:32

踩

unity 对象池

一、什么是对象池

对象池（英语：object pool pattern）是一种设计模式。一个对象池包含一组已经初始化过且可以使用的对象，而可以在有需求时创建和销毁对象。池的用户可以从池子中取得对象，对其进行操作处理，并在不需要时归还给池子而非直接销毁它。这是一种特殊的工厂对象。

若初始化、实例化的代价高，且有需求需要经常实例化，但每次实例化的数量较少的情况下，使用对象池可以获得显著的效能提升。从池子中取得对象的时间是可预测的，但新建一个实例所需的时间是不确定。来自Wikipedia

二、对象池开发思路

当开发一个对象池（Object Pool）时，首先需要明确对象池的概念和作用。对象池是一种优化技术，用于管理游戏中频繁创建和销毁的对象，例如子弹、敌人或者其他游戏元素。通过对象池，可以减少频繁的内存分配和垃圾回收，从而提高游戏的性能。

下面是在Unity中开发对象池的一般思路：

确定需要使用对象池的对象类型：首先，确定哪些游戏对象需要使用对象池。通常是那些频繁创建和销毁的对象，比如子弹、敌人、特效等。
创建对象池管理器：在Unity中，可以创建一个单例的对象池管理器来统一管理所有对象池。该管理器可以负责创建、获取、回收和销毁对象。
编写对象池类：创建一个对象池类，用于管理特定类型的对象。这个类需要包含以下功能：
- 初始化对象池：在游戏开始时，预先创建一定数量的对象并存入对象池。
- 获取对象：当需要使用对象时，从对象池中获取对象。如果没有可用对象，则可以选择扩展对象池或者创建新对象。
- 回收对象：当对象不再需要时，将其回收到对象池中以便重复利用。
- 可选的功能：例如自动扩展、限制对象数量等。
在游戏中使用对象池：在游戏中，通过对象池管理器获取需要的对象，而不是直接使用Instantiate来创建新对象。当对象不再需要时，将其回收到对象池中。
优化和扩展：可以根据具体需求对对象池进行优化和扩展，例如：
- 实现对象池的预加载，提前创建一定数量的对象以减少游戏运行时的性能开销。
- 使用对象池事件来处理对象的创建、获取、回收等操作，以实现更灵活的控制和扩展。
- 在对象池中实现对象的复用机制，避免频繁创建和销毁对象，进一步提高性能。
测试和调优：在开发完成后，进行测试并根据性能测试结果进行调优，确保对象池能够在不影响游戏性能的情况下有效地管理对象。

综上所述，开发Unity对象池需要明确对象类型、创建对象池管理器、编写对象池类、在游戏中使用对象池、优化和扩展对象池功能，最终进行测试和调优。通过合理使用对象池，可以提高游戏性能并改善游戏体验。

三、对象池基础开发--代码

对象池，简单来说就是把需要复用的对象放入合适的数据结构中，用的时候拿出来，用完就放回去，数据结构里没有那就再创建

所以，确立了思路，那就简单的写一下对象池的基础版

在这个对象池简易版中，使用了单例模式、栈以及字典(详细使用请看书)，栈就是缓存池的容器，而字典的目的是创建多个缓存池保存在字典中，通过键值对进行索引归类操作

1. 对象池基础版代码


using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class ObjectPoolManager
{
    /// <summary>
    /// 单例模式
    /// </summary>
    private static ObjectPoolManager objectPoolManager;
    public static ObjectPoolManager GetObjectPoolManager()
    {
        if(objectPoolManager == null)
        {
            objectPoolManager = new ObjectPoolManager();
        }
 
        return objectPoolManager;
    }
    // 存放所有的缓存池，根据名字进行区分
    private Dictionary<string, Stack<GameObject>> objectPoolDic = new Dictionary<string, Stack<GameObject>>();
 
 
    /// <summary>
    /// 创建对象
    /// 没有缓存池创建缓存池
    /// </summary>
    /// <param name="name">需要创建的物体的路径</param>
    /// <returns></returns>
    public GameObject CreateObject(string name)
    {
 
        GameObject obj;
        // 判断有没有缓存池
        if(objectPoolDic.ContainsKey(name) && objectPoolDic[name].Count > 0)
        {
            // 如果有缓存池，直接返回，并且激活
            obj = objectPoolDic[name].Pop();
        }
        else
        {
            // 如果没有缓存池，直接创建
            obj = GameObject.Instantiate(Resources.Load<GameObject>(name));
            obj.name = name;
        }
 
        return obj;
    }
 
    /// <summary>
    /// 添加到缓存池中
    /// </summary>
    /// <param name="gameObject">需要添加的物体</param>
    public void AddObjectPool(GameObject gameObject)
    {
        // 判断有没有缓存池
        if(!objectPoolDic.ContainsKey(gameObject.name))
            // 没有缓存池，创建缓存池，把数据存入到缓存池中
            objectPoolDic.Add(gameObject.name, new Stack<GameObject>());
        objectPoolDic[gameObject.name].Push(gameObject);
    }
 
 
    /// <summary>
    /// 清除缓存池
    /// 在切换场景时调用
    /// </summary>
    public void ClearDic()
    {
        objectPoolDic.Clear();
    }
}

2.对象池的使用

鼠标点击创建子弹，一秒后放入对象池

具体资源加载翻阅Unity官方手册


using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class InputSystem : MonoBehaviour
{
    private void Update()
    {
        if(Input.GetMouseButtonDown(0))
        {
            GameObject obj = ObjectPoolManager.GetObjectPoolManager().CreateObject("Prefab/Bullet");
            obj.SetActive(true);
        }
    }
}
 
 
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class Bullet : MonoBehaviour
{
    private void OnEnable()
    {
        Invoke("Remove", 1f);
    }
 
    private void Remove()
    {
        ObjectPoolManager.GetObjectPoolManager().AddObjectPool(this.gameObject);
        obj.SetActive(false);
    }
}

四、升级拓展--创建并添加组件(利用泛型)

基础版中，从Resources中加载物体，所有的对象都是预定的，那么想要更加便捷的添加一些对象并附着一些组件。例如，场景中有多个需要同时触发音效的对象，而提前不确定有多少个，那么就可以使用对象池加载一些对象，并且添加AudioSource组件，使用的时候只需要创建物体获取组件操作即可，当然，也不止可以添加AudioSource组件，所以将使用泛型来代替组件类型，这样就可以做到对象池的共用

1.代码


using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
// 泛型，用于设置  组件 类型 及可添加任意组件
public class ObjectPoolManagerTest<T> where T : Component
{
    /// <summary>
    /// 单例模式
    /// </summary>
    private static ObjectPoolManagerTest<T> objectPoolManagerTest;
    public static ObjectPoolManagerTest<T> GetObjectPoolManagerTest()
    {
        if(objectPoolManagerTest == null)
        {
            objectPoolManagerTest = new ObjectPoolManagerTest<T>();
        }
 
        return objectPoolManagerTest;
    }
    // 存放所有的缓存池，根据名字进行区分
    private Dictionary<string, Stack<GameObject>> objectPoolDic = new Dictionary<string, Stack<GameObject>>();
 
 
    /// <summary>
    /// 创建对象
    /// 没有缓存池创建缓存池
    /// </summary>
    /// <param name="name">需要创建的物体的路径</param>
    /// <returns></returns>
    public GameObject CreateObject(string name, GameObject parentObj)
    {
 
        GameObject obj;
        // 判断有没有缓存池
        if(objectPoolDic.ContainsKey(name) && objectPoolDic[name].Count > 0)
        {
            // 如果有缓存池，直接返回，并且激活
            obj = objectPoolDic[name].Pop();
            // obj.SetActive(true);
        }
        else
        {
            // 如果没有缓存池，直接创建
            obj = new GameObject("音效2");
            // 设置父物体，便于管理
            obj.transform.SetParent(parentObj.transform);
            // 添加泛型组件
            obj.AddComponent<T>() ;
            obj.name = name;
        }
 
        return obj;
    }
 
    /// <summary>
    /// 添加到缓存池中
    /// </summary>
    /// <param name="gameObject">需要添加的物体</param>
    public void AddObjectPool(GameObject gameObject)
    {
        // gameObject.SetActive(false);
 
        // 判断有没有缓存池
        if(!objectPoolDic.ContainsKey(gameObject.name))
            // 没有缓存池，创建缓存池，把数据存入到缓存池中
            objectPoolDic.Add(gameObject.name, new Stack<GameObject>());
        objectPoolDic[gameObject.name].Push(gameObject);
    }
 
 
    /// <summary>
    /// 清除缓存池
    /// 在切换场景时调用
    /// </summary>
    public void ClearDic()
    {
        objectPoolDic.Clear();
    }
}

2.使用


using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class AudioSourceManager : MonoBehaviour
{
    [SerializeField] private AudioClip[] audioClips;
    
 
    void Update()
    {
        if(Input.GetKeyDown(KeyCode.Z))
        {
            PlayAudioTest(0);
        }
        if(Input.GetKeyDown(KeyCode.X))
        {
            PlayAudioTest(1);
        }
        if(Input.GetKeyDown(KeyCode.C))
        {
            PlayAudioTest(2);
        }
    }
 
 
    private void PlayAudioTest(int index)
    {
        GameObject obj = ObjectPoolManagerTest<AudioSource>.GetObjectPoolManagerTest().CreateObject(this.gameObject.name, this.gameObject);
        AudioSource audioSource = obj.GetComponent<AudioSource>();
        obj.SetActive(true);
        audioSource.clip = audioClips[index];
        audioSource.Play();
        StartCoroutine(CheckAudioFinishedTest(audioSource, obj));
    }
 
 
    IEnumerator CheckAudioFinishedTest(AudioSource audioSource, GameObject obj)
    {
        // 等待音效播放完成
        while (audioSource.isPlaying)
        {
            // 延迟一秒执行
            yield return new WaitForSecondsRealtime(1f);
        }
 
        // 音效播放完成后的操作
        ObjectPoolManagerTest<AudioSource>.GetObjectPoolManagerTest().AddObjectPool(obj);
        obj.SetActive(false);
    }
}

五、加强版--泛型对象池

上面已经写了两个版本的对象池，一个是管理GameObject，另一个是管理Component的，但是这两个不能交叉使用，emm

泛型可以使对象池添加任意Component组件，那么，泛型可以不可以将GameObject和Component结合起来，需要使用的时候再确定变量

这个想法可行，干就完了

1.代码


using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class GenericsObjectPoolManager<T> where T : UnityEngine.Object
{
    /// <summary>
    /// 单例模式
    /// </summary>
    private static GenericsObjectPoolManager<T> genericsObjectPoolManager;
    public static GenericsObjectPoolManager<T> GetObjectPoolManager()
    {
        if(genericsObjectPoolManager == null)
        {
            genericsObjectPoolManager = new GenericsObjectPoolManager<T>();
        }
 
        return genericsObjectPoolManager;
    }
 
    
 
    // 存放所有的对象池，根据名字进行区分
    private Dictionary<string, Stack<T>> genericsObjectPoolDic = new Dictionary<string, Stack<T>>();
 
 
 
    /// <summary>
    /// 创建对象
    /// 没有对象池创建对象池
    /// </summary>
    /// <param name="name">需要创建的物体的路径</param>
    /// <returns></returns>
    public T CreateObject(string name)
    {
 
        T obj;
        // 判断有没有对象池
        if(genericsObjectPoolDic.ContainsKey(name) && genericsObjectPoolDic[name].Count > 0)
        {
            // 如果有对象池，直接返回，并且激活
            obj = genericsObjectPoolDic[name].Pop();
        }
        else
        {
            // 如果没有对象池，直接创建
            obj = GameObject.Instantiate(Resources.Load<T>(name));
            obj.name = name;
        }
 
        return obj;
    }
 
    /// <summary>
    /// 创建对象  音频对象池
    /// 没有对象池创建对象池
    /// 创建对象池函数重载
    /// </summary>
    /// <param name="name">对象池索引名字</param>
    /// <returns></returns>
    public T CreateObject(string name, GameObject obj)
    {
        T t;
 
        if (genericsObjectPoolDic.ContainsKey(name) && genericsObjectPoolDic[name].Count > 0)
        {
            t = genericsObjectPoolDic[name].Pop();
        }
        else
        {
            GameObject gameObject = new GameObject("音效");
            gameObject.transform.SetParent(obj.transform);
            t = gameObject.AddComponent(typeof(T)) as T;
        }
 
        return t;
    }
 
    /// <summary>
    /// 添加到对象池中
    /// </summary>
    /// <param name="gameObject">需要添加的物体</param>
    public void AddObjectPool(T t)
    {
        // 判断有没有对象池
        if(!genericsObjectPoolDic.ContainsKey(t.name))
            // 没有对象池，创建对象池，把数据存入到对象池中
            genericsObjectPoolDic.Add(t.name, new Stack<T>());
        genericsObjectPoolDic[t.name].Push(t);
    }
 
    /// <summary>
    /// 添加到对象池中
    /// 重载
    /// </summary>
    /// <param name="gameObject">索引名字</param>
    public void AddObjectPool(string name, T t)
    {
        // 判断有没有对象池
        if(!genericsObjectPoolDic.ContainsKey(name))
            // 没有对象池，创建对象池，把数据存入到对象池中
            genericsObjectPoolDic.Add(name, new Stack<T>());
        genericsObjectPoolDic[name].Push(t);
    }
 
 
    /// <summary>
    /// 清除对象池
    /// 在切换场景时调用
    /// </summary>
    public void ClearDic()
    {
        genericsObjectPoolDic.Clear();
    }
}

2.使用

1.GameObject类型


using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class InputSystem : MonoBehaviour
{
    [SerializeField] private AudioClip audioClip;
 
    private void Update()
    {
        if(Input.GetMouseButtonDown(1))
        {
            GameObject obj = GenericsObjectPoolManager<GameObject>.GetObjectPoolManager().CreateObject("Prefab/GBullet");
            obj.SetActive(true);
        }
    }
}

2. Component类型

以AudioSource举例


using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class AudioSourceManager : MonoBehaviour
{
    [SerializeField] private AudioClip[] audioClips;
    
 
    void Update()
    {
        if(Input.GetKeyDown(KeyCode.A))
        {
            PlayAudio(0);
        }
        if(Input.GetKeyDown(KeyCode.S))
        {
            PlayAudio(1);
        }
        if(Input.GetKeyDown(KeyCode.D))
        {
            PlayAudio(2);
        }
    }
 
    private void PlayAudio(int index)
    {
        AudioSource audioSource = GenericsObjectPoolManager<AudioSource>.GetObjectPoolManager().CreateObject(this.gameObject.name, this.gameObject);
        audioSource.GetComponent<Transform>().gameObject.SetActive(true);
        audioSource.clip = audioClips[index];
        audioSource.Play();
        StartCoroutine(CheckAudioFinished(audioSource));
    }
 
    IEnumerator CheckAudioFinished(AudioSource audioSource)
    {
        // 等待音效播放完成
        while (audioSource.isPlaying)
        {
            // 延迟一秒执行
            yield return new WaitForSecondsRealtime(1f);
        }
 
        // 音效播放完成后的操作
        GenericsObjectPoolManager<AudioSource>.GetObjectPoolManager().AddObjectPool(this.gameObject.name, audioSource);
        audioSource.GetComponent<Transform>().gameObject.SetActive(false);
    }
 
}

六、附加

在使用音效管理的对象池，可以简单的写一个音频框架，更加方便便捷的进行音效的播放，具体可以看我的另一篇博客

音效框架http://t.csdnimg.cn/rV3Ya

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/木道寻08/article/detail/1011045