Unity对象池技术复习

原创于 2025-03-28 14:53:24 发布 · 776 阅读

本内容遵循CC 4.0 BY-SA版权协议

对象池(Object Pooling)是一种优化技术，用于管理可重用对象的创建和回收，特别适用于需要频繁创建和销毁相同类型对象的场景(如子弹、敌人、特效等)。在Unity中使用对象池可以显著减少实例化(Instantiate)和销毁(Destroy)操作带来的性能开销。

一、对象池的基本原理

对象池的核心思想是：

预先创建一定数量的对象并存储在池中
当需要对象时从池中获取而不是新建
使用完毕后将对象返回池中而不是销毁
池中没有可用对象时可以选择扩展池或等待

二、Unity中实现对象池的几种方式

1. 手动实现基础对象池

using System.Collections.Generic;
using UnityEngine;

public class SimpleObjectPool : MonoBehaviour
{
    public GameObject prefab;
    public int initialSize = 10;
    
    private Queue<GameObject> objectPool = new Queue<GameObject>();

    private void Start()
    {
        InitializePool();
    }

    private void InitializePool()
    {
        for (int i = 0; i < initialSize; i++)
        {
            GameObject obj = Instantiate(prefab);
            obj.SetActive(false);
            objectPool.Enqueue(obj);
        }
    }

    public GameObject GetObject()
    {
        if (objectPool.Count > 0)
        {
            GameObject obj = objectPool.Dequeue();
            obj.SetActive(true);
            return obj;
        }
        else
        {
            // 池中没有对象时创建新对象
            GameObject obj = Instantiate(prefab);
            return obj;
        }
    }

    public void ReturnObject(GameObject obj)
    {
        obj.SetActive(false);
        objectPool.Enqueue(obj);
    }
}

2. 使用Stack实现的通用对象池

using System.Collections.Generic;
using UnityEngine;

public class GenericObjectPool<T> where T : Component
{
    private Stack<T> pool;
    private T prefab;
    private Transform parent;

    public GenericObjectPool(T prefab, int initialSize, Transform parent = null)
    {
        this.prefab = prefab;
        this.parent = parent;
        pool = new Stack<T>(initialSize);
        
        for (int i = 0; i < initialSize; i++)
        {
            T obj = GameObject.Instantiate(prefab, parent);
            obj.gameObject.SetActive(false);
            pool.Push(obj);
        }
    }

    public T Get()
    {
        if (pool.Count > 0)
        {
            T obj = pool.Pop();
            obj.gameObject.SetActive(true);
            return obj;
        }
        
        return GameObject.Instantiate(prefab, parent);
    }

    public void Return(T obj)
    {
        obj.gameObject.SetActive(false);
        pool.Push(obj);
    }
}

3. Unity官方对象池(Unity 2021+)

Unity 2021及以上版本提供了内置的对象池API：

using UnityEngine;
using UnityEngine.Pool;

public class UnityObjectPoolExample : MonoBehaviour
{
    public GameObject prefab;
    private IObjectPool<GameObject> pool;

    private void Awake()
    {
        pool = new ObjectPool<GameObject>(
            createFunc: () => Instantiate(prefab),
            actionOnGet: (obj) => obj.SetActive(true),
            actionOnRelease: (obj) => obj.SetActive(false),
            actionOnDestroy: (obj) => Destroy(obj),
            collectionCheck: false,
            defaultCapacity: 10,
            maxSize: 100
        );
    }

    public GameObject GetObject()
    {
        return pool.Get();
    }

    public void ReleaseObject(GameObject obj)
    {
        pool.Release(obj);
    }
}

三、对象池的高级应用

1. 带自动回收的对象池

public class AutoReturnPool : MonoBehaviour
{
    // ... 其他对象池代码
    
    public GameObject GetObject(float lifeTime)
    {
        GameObject obj = GetObject();
        StartCoroutine(ReturnAfterTime(obj, lifeTime));
        return obj;
    }

    private IEnumerator ReturnAfterTime(GameObject obj, float time)
    {
        yield return new WaitForSeconds(time);
        ReturnObject(obj);
    }
}

2. 多层级对象池(管理不同类型的对象)

using System.Collections.Generic;
using UnityEngine;

public class MultiObjectPool : MonoBehaviour
{
    [System.Serializable]
    public class Pool
    {
        public string tag;
        public GameObject prefab;
        public int size;
    }

    public List<Pool> pools;
    public Dictionary<string, Queue<GameObject>> poolDictionary;

    private void Start()
    {
        poolDictionary = new Dictionary<string, Queue<GameObject>>();

        foreach (Pool pool in pools)
        {
            Queue<GameObject> objectPool = new Queue<GameObject>();
            
            for (int i = 0; i < pool.size; i++)
            {
                GameObject obj = Instantiate(pool.prefab);
                obj.SetActive(false);
                objectPool.Enqueue(obj);
            }
            
            poolDictionary.Add(pool.tag, objectPool);
        }
    }

    public GameObject SpawnFromPool(string tag, Vector3 position, Quaternion rotation)
    {
        if (!poolDictionary.ContainsKey(tag))
        {
            Debug.LogWarning($"Pool with tag {tag} doesn't exist.");
            return null;
        }

        GameObject objectToSpawn = poolDictionary[tag].Dequeue();
        
        objectToSpawn.SetActive(true);
        objectToSpawn.transform.position = position;
        objectToSpawn.transform.rotation = rotation;

        IPooledObject pooledObj = objectToSpawn.GetComponent<IPooledObject>();
        if (pooledObj != null)
        {
            pooledObj.OnObjectSpawn();
        }

        poolDictionary[tag].Enqueue(objectToSpawn);
        
        return objectToSpawn;
    }
}

public interface IPooledObject
{
    void OnObjectSpawn();
}