unity對象池

這套對象池原理比較簡單， 由一個管理器和一個池子組成，池子裏存儲多個對象池，每個對象池對應一個對象的池，即該對象池內存儲實例化的該對象，有管理器持有，統一管理

關於原理什麼的不多說，直接上代碼

管理器：

/// <summary>
/// 簡易對象池
/// </summary>
public class ObjectPoolMgr : MgrBase
{
    public static ObjectPoolMgr instance;

    /// <summary>
    /// 可回收物體
    /// </summary>
    public List<InitInfo> recycleObjs;

    /// <summary>
    /// 所有的池子
    /// </summary>
    public Dictionary<ObjID, ObjectPool> objPools = new Dictionary<ObjID, ObjectPool>();

    /// <summary>
    /// 遊戲中使用的
    /// </summary>
    public Transform GameObjs;
    /// <summary>
    /// 初始化的
    /// </summary>
    public Transform InitObjs;

    public override void OnAwake()
    {
        base.OnAwake();
        instance = this;

    }

    /// <summary>
    /// 初始化
    /// </summary>
    private void Init()
    {
        List<string> paths = new List<string>();
        for (int i = 0; i < recycleObjs.Count; i++)
        {
            if (!recycleObjs[i].InitOnStart) continue;
            string path = GetPath(recycleObjs[i].ID);
            if (!string .IsNullOrEmpty(path))
            {
                paths.Add(path);
            }else
            {
                Debuger.Log("請先配置預設路徑:"+recycleObjs [i],Color .red);
                return;
            }
        }
        MsgMore<string, Action<GameObject[]>> msg = MsgCenter.Instance.GetMsgMore<string, Action<GameObject[]>>(paths,new List<Action<GameObject[]>>()
        {
            pres =>
            {
                 for (int i = 0; i < pres.Length; i++)
                {
                    GameObject obj = new GameObject ();
                    obj .transform .SetParent  (InitObjs);
                    obj.name = pres[i].name;
                    ObjectPool pool = obj.AddComponent<ObjectPool>();
                    PoolObj poolobj=pres[i].GetComponent <PoolObj >();
                    pool .InitPool(poolobj, obj.transform);
                    objPools.Add(poolobj.ID,pool);
                    Debuger.Log("初始化對象池：" + pool.Count + "  id:" + pool.ID);
                }
            }
        }) as MsgMore<string, Action<GameObject[]>>;
        msg.manager = MgrID.AssetsManager;
        msg.msgID = (ushort)AssetMsgID.LoadSourceSync;
        Send(msg);
    }
    /// <summary>
    /// 申請
    /// </summary>
    private GameObject []  Apply(ObjID id,int count)
    {
        ObjectPool pool;
        if (objPools .TryGetValue (id ,out pool))
        {
            return pool.Apply(count);
        }
        Debuger.Log("申請對象未註冊進對象池，請檢查：" + id);
        return null;
    }
    public override void ProcessMsg(MsgBase msg)
    {
        ObjcectPoolMsgID id = (ObjcectPoolMsgID)msg.msgID;
        switch (id)
        {
            case ObjcectPoolMsgID.Init:
                Init();
                break;
            case ObjcectPoolMsgID.CreatCardsPool:
                if (objPools .Count > 0)
                {
                    ClearPool();
                }
                List<string> paths = new List<string>() { GetPath(ObjID.BeautyCard ), GetPath(ObjID.CardUI), GetPath(ObjID.FightingCard)};
                MsgMore<string, Action<GameObject[]>> getobjs = MsgCenter.Instance.GetMsgMore<string, Action<GameObject[]>>(paths, new List<Action<GameObject[]>>()
        {
            pres =>
            {
                 for (int i = 0; i < pres.Length; i++)
                {
                    GameObject obj = new GameObject ();
                    obj .transform .SetParent  (GameObjs  );
                    obj.name = pres[i].name;
                    ObjectPool pool = obj.AddComponent<ObjectPool>();
                    PoolObj poolobj=pres[i].GetComponent <PoolObj >();
                    pool .InitPool(poolobj, obj.transform);
                    objPools.Add(poolobj.ID,pool);
                    Debuger.Log("初始化對象池：" + pool.Count + "  id:" + pool.ID);
                }
               (msg as MsgOne <Action >).valuelist [0].Invoke ();
                msg .Recyle ();
            }
        }) as MsgMore<string, Action<GameObject[]>>;
                getobjs.manager = MgrID.AssetsManager;
                getobjs.msgID = (ushort)AssetMsgID.LoadSourceSync;
                Send(getobjs);
                return ;
            case ObjcectPoolMsgID.ApplyObj:
                MsgMore<int, Action<GameObject[]>> apply = msg as MsgMore<int, Action<GameObject[]>>;
                apply.T2list[0].Invoke(Apply((ObjID)apply.T1list[0], apply.T1list[1]));
                break;
            case ObjcectPoolMsgID.ClearGameObjs:
                ClearPool();
                break;
        }
        msg.Recyle();
    }
    private void ClearPool()
    {
        for (int i = 0; i < GameObjs.childCount; i++)
        {
            Destroy(GameObjs.GetChild(i).gameObject);
        }
        objPools.Clear();
    }
    /// <summary>
    /// /獲取路徑
    /// </summary>
    /// <param name="ID"></param>
    /// <returns></returns>
    private string GetPath(ObjID ID)
    {
        switch (ID)
        {
            case ObjID.None:
                break;
            case ObjID.CardUI:
                return "Prefabs/UI/PlayerCardUI";
            case ObjID.FightingCard:
                return "Prefabs/UI/SingleCardFighting";
            case ObjID.BeautyCard:
                return "Prefabs/UI/BeautyCard";
        }
        return "";
    }
}

對象池：

public enum ObjID
{
    None,
    /// <summary>
    /// 卡片
    /// </summary>
    CardUI=1,
}

/// <summary>
/// 對象池
/// </summary>
public class ObjectPool:PartBase
{
    /// <summary>
    /// 池子
    /// </summary>
    public Queue <PoolObj> objectPool;

    /// <summary>
    /// 唯一標識， 對應於回收對象的ID
    /// </summary>
    public ObjID ID;

    /// <summary>
    /// 活躍池
    /// </summary>
    public List<PoolObj> activePool;

    /// <summary>
    /// 池子存儲位置
    /// </summary>
    public Transform poolTr;

    /// <summary>
    /// 預製
    /// </summary>
    public PoolObj pre;

    public int Count
    {
        get
        {
            return objectPool.Count;
        }
    }

    /// <summary>
    /// 構造函數
    /// </summary>
    /// <param name="obj"></param>
    public void InitPool(PoolObj obj,Transform tr)
    {
        poolTr = tr;
        //poolTr.gameObject.SetActive(false);
        pre = obj;
        objectPool = new Queue<PoolObj>();
        activePool = new List<PoolObj>();
        ID = obj .ID;

        for (int i = 0; i < obj .MaxCountInPool; i++)
        {
            objectPool.Enqueue(CreatNew().GetComponent <PoolObj >());
        }
    }
    /// <summary>
    ///創建新的
    /// </summary>
    private GameObject CreatNew(bool active = false)
    {
        GameObject clone = GameObject.Instantiate(pre, poolTr).gameObject;
        clone.SetActive(active);
        return clone;
    }

    /// <summary>
    /// 申請
    /// </summary>
    /// <param name="count"></param>
    /// <returns></returns>
    public GameObject [] Apply(int count)
    {
        GameObject[] objs = new GameObject[count];
        int index = 0;
        while (objectPool.Count >0 && index <count)
        {
            PoolObj obj = objectPool.Dequeue();
            objs[index] = obj.gameObject;
            obj.gameObject.SetActive(true);
            obj.OnActive(recyle=> { Recyle(recyle); });
            index ++;
            activePool.Add(obj);
        }
        for (int i = index ; i < count; i++)
        {
            objs[i] = CreatNew(true);
            PoolObj ob = objs[i].GetComponent<PoolObj>();
            ob.OnActive(recyle => { Recyle(recyle); });
            activePool.Add(ob);
        }
        return objs;
    }

    /// <summary>
    /// 回收
    /// </summary>
    /// <param name="obj"></param>
    /// <returns></returns>
    public bool Recyle(PoolObj obj)
    {
        if (obj.ID != ID) return false;
        obj.gameObject.SetActive(false);
        obj.transform.SetParent(transform);
        activePool.Remove(obj);
        objectPool.Enqueue(obj);
        return true;
    }

  

    /// <summary>
    /// 刪除池子 --棄用
    /// </summary>
    public void DestroySelf()
    {
        for (int i = 0; i < activePool .Count ; i++)
        {
            GameObject.Destroy(activePool[i]);
        }
        while (objectPool .Count >0)
        {
            GameObject.Destroy(objectPool.Dequeue().gameObject);
        }
    }
}

對於要放入對象池的物體，要掛載下邊的腳本，並進行配置：

/// <summary>
/// 注入對象池的物體  掛載的腳本 
/// </summary>
public class PoolObj : MonoBehaviour
{
    /// <summary>
    /// 是否自動回收
    /// </summary>
    [HideInInspector ]
    public bool AutoRecyle;

    /// <summary>
    /// 自動回收計時
    /// </summary>
    [SerializeField]
    private float recyleTime;

    /// <summary>
    /// 該對象在池中的最多個數
    /// </summary>
    public int MaxCountInPool;

    /// <summary>
    /// 對象標識 每種對象對應一個
    /// </summary>
    public ObjID ID;

    /// <summary>
    /// 是否已經回收
    /// </summary>
    public bool HasRecyle;

    private float revTime;//當前剩餘時間回收

    /// <summary>
    /// 回收事件
    /// </summary>
    private Action<PoolObj> OnRecyle;

    /// <summary>
    /// 激活對象
    /// </summary>
    public void OnActive(Action<PoolObj> act )
    {
        revTime = recyleTime;
        HasRecyle =false;
        OnRecyle = act;
    }
    /// <summary>
    /// 刷新回收時間
    /// </summary>
    public void UpdateTime()
    {
        if (AutoRecyle&&!HasRecyle)
        {
            revTime -= Time.deltaTime;
            if (revTime < 0)
            {
                Recyle();
            }
        }
    }

    /// <summary>
    ///回收
    /// </summary>
    public virtual void Recyle()
    {
        HasRecyle = true;
        if (OnRecyle !=null)
        {
            OnRecyle(this);
        }
    }

}

使用：

  在場景中掛載管理器腳本，配置一下要在運行時初始化的對象的id，這樣在遊戲運行時會吧配置的對象創建到對應的池子裏

  你可以指定初始化的個數，也就是在池子中的最高數量，當全部取出後，再次申請會重新創建，該數量基於實際情況設置，即同時存在場景中的峯值即可，當然，可多可少！