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，这样在游戏运行时会吧配置的对象创建到对应的池子里

  你可以指定初始化的个数，也就是在池子中的最高数量，当全部取出后，再次申请会重新创建，该数量基于实际情况设置，即同时存在场景中的峰值即可，当然，可多可少！