Unity性能优化之对象池管理器PoolManager

最新推荐文章于 2024-10-06 10:50:58 发布
最新推荐文章于 2024-10-06 10:50:58 发布
阅读量3.7k 收藏 12
点赞数 1
分类专栏： Unity3d游戏开发 文章标签： PoolManager 性能优化 对象池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yye4520/article/details/89147558
版权

简介

什么是对象池？顾名思义，就是存放实例对象的池子，即缓冲区。一般对象池在初始化时会包含着若干个实例对象，当我们需要时便从池子里取出来，当不需要时便放回对象池里面。使用对象池不需要频繁的产生和销毁实例对象，当对象池中的实例对象不够用时才会继续产生实例对象，这大大的节省了性能。所以在很多频繁使用实例对象的场景中，我们常常可以看到对象池的身影，比如数据库连接池、线程池、任务队列池和大量的游戏场景。

PoolManager

我在空余时间写了一个unity的对象池管理PoolManager，除了实现了一般对象池功能，还对其做出了拓展，比如自动回收，自动删除长时间没用的对象，实例对象数量的限制等等，大家可以根据自己项目的需求对代码进行修改和拓展。

// <Licensing>
// Copyright (C) XM.All Rights Reserved.
// Author: 吴肖牧（XM）
// Date: 2019-03-26
// Desc: 对象池管理器
// <Licensing>

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using XMFramework;

public class PoolManager : GameBase
{
    private Dictionary<string, SpawnPool> _pools = new Dictionary<string, SpawnPool>();

    public Dictionary<string, SpawnPool> GetPools()
    {
        return _pools;
    }

    public bool CreatePool(string poolName)
    {
        if (_pools.TryGetValue(poolName, out SpawnPool spawnPool))
        {
            XMDebug.Log("已存在对象池", poolName);
            return false;
        }
        SpawnPool pool = new GameObject(poolName + "Pool").AddComponent<SpawnPool>();
        pool.transform.SetParent(transform);
        pool.poolName = poolName;
        _pools.Add(poolName, pool);
        return true;
    }

        public bool RemovePool(string poolName)
        {
            if (!_pools.TryGetValue(poolName, out SpawnPool spawnPool))
            {
                XMDebug.Log("找不到对象池", poolName);
                return false;
            }
            spawnPool.Clean();
            Destroy(spawnPool.gameObject);
            _pools.Remove(spawnPool.poolName);
            Util.ClearMemory();
            return true;
        }

        public bool RemovePool(SpawnPool spawnPool)
        {
            if (ContainsValue(spawnPool))
            {
                spawnPool.Clean();
                Destroy(spawnPool.gameObject);
                _pools.Remove(spawnPool.poolName);
                Util.ClearMemory();
                return true;
            }
            else
            {
                XMDebug.Log("找不到对象池", spawnPool.poolName);
                return false;
            }
        }

    public SpawnPool GetSpawnPool(string poolName)
    {
        if (!_pools.TryGetValue(poolName, out SpawnPool spawnPool))
        {
            XMDebug.Log("找不到对象池", poolName);
            return null;
        }
        return _pools[poolName];
    }

    public bool ContainsKey(string poolName)
    {
        return _pools.ContainsKey(poolName);
    }

    public bool ContainsValue(SpawnPool pool)
    {
        return _pools.ContainsValue(pool);
    }

    public void CleanPool()
    {
        foreach (KeyValuePair<string, SpawnPool> pair in _pools)
        {
            if (pair.Value.gameObject)
            {
                Destroy(pair.Value.gameObject);
            }
        }
        _pools.Clear();
        Util.ClearMemory();
    }
}

 

// <Licensing>
// Copyright (C) XM.All Rights Reserved.
// Author: 吴肖牧（XM）
// Date: 2019-04-02
// Desc: 对象池生产器
// <Licensing>

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using XMFramework;

public class SpawnPool : GameBase
{
    public string poolName = "";

    [SerializeField]
    private List<PrefabPool> _prefabPools = new List<PrefabPool>();

    private List<Transform> _spawned = new List<Transform>();//存放所有对象，暂时没用到

    #region Prefab
    public void AddPrefab(PrefabPool prefabPool)
    {
        if (_prefabPools.Contains(prefabPool))
        {
            XMDebug.Log("已存在对象", prefabPool);
            return;
        }

        prefabPool.prefabScale = prefabPool.prefab.localScale;

        _prefabPools.Add(prefabPool);

        if (prefabPool.initDespawnCount > 0)
        {
            for (int i = 0; i < prefabPool.initDespawnCount; i++)
            {
                Transform inst = Instantiate<Transform>(prefabPool.prefab, Vector3.zero, Quaternion.identity, transform);
                prefabPool._despawned.Add(inst);
                inst.name = inst.name.Replace("(Clone)", "");
                inst.gameObject.SetActive(false);
            }
        }

        StartCoroutine(TidyDespawn(prefabPool));
    }

    public void DelPrefab(PrefabPool prefabPool)
    {
        if (_prefabPools.Contains(prefabPool))
        {
            _prefabPools.Remove(prefabPool);
        }
        else
        {
            XMDebug.Log("找不到对象", prefabPool);
        }
    }
    #endregion

    #region SpawnPrefab
    public Transform Spawn(Transform prefab)
    {
        return Spawn(prefab, Vector3.zero, Quaternion.identity);
    }

    public Transform Spawn(Transform prefab, Transform parent)
    {
        return Spawn(prefab, Vector3.zero, Quaternion.identity, parent);
    }

    public Transform Spawn(Transform prefab, Vector3 pos, Quaternion rot)
    {
        Transform inst = Spawn(prefab, pos, rot, transform);

        if (inst == null) return null;

        return inst;
    }

    public Transform Spawn(Transform prefab, Vector3 pos, Quaternion rot, Transform parent)
    {
        Transform inst = Spawn(prefab.name, pos, rot, parent);

        return inst;
    }
    #endregion

    #region SpawnPrefabName
    public Transform Spawn(string prefabName)
    {
        return Spawn(prefabName, Vector3.zero, Quaternion.identity);
    }

    public Transform Spawn(string prefabName, Transform parent)
    {
        return Spawn(prefabName, Vector3.zero, Quaternion.identity, parent);
    }

    public Transform Spawn(string prefabName, Vector3 pos, Quaternion rot)
    {
        Transform inst = Spawn(prefabName, pos, rot, transform);

        if (inst == null) return null;

        return inst;
    }

    public Transform Spawn(string prefabName, Vector3 pos, Quaternion rot, Transform parent)
    {
        Transform inst = null;

        for (int i = 0; i < _prefabPools.Count; i++)
        {
            PrefabPool prefabPool = _prefabPools[i];
            if (prefabPool.prefab.name == prefabName)
            {
                if (prefabPool.spawnMaxLimit > 0 && prefabPool._spawned.Count >= prefabPool.spawnMaxLimit)
                {
                    return null;
                }

                if (prefabPool._despawned.Count > 0)
                {
                    inst = prefabPool._despawned[0];
                    prefabPool._despawned.RemoveAt(0);
                    inst.gameObject.SetActive(true);
                }
                else
                {
                    inst = Instantiate<Transform>(prefabPool.prefab, pos, rot, parent);
                    inst.name = inst.name.Replace("(Clone)", "");
                }

                prefabPool._spawned.Add(inst);

                if (prefabPool.autoDespawnTime > 0)
                {
                    StartCoroutine(AutoDespawn(inst, prefabPool.autoDespawnTime));
                }
                break;
            }
        }

        if (inst == null) return null;

        _spawned.Add(inst);

        return inst;
    }

    #endregion

    #region Despawn
    /// <summary>
    /// 销毁对象，销毁传的对象
    /// </summary>
    /// <param name="prefab">对象</param>
    public void Despawn(Transform prefab)
    {
        if (prefab == null)
        {
            return;
        }
        Transform inst = null;

        for (int i = 0; i < _prefabPools.Count; i++)
        {
            PrefabPool prefabPool = _prefabPools[i];
            if (prefabPool.prefab.name == prefab.name)
            {
                if (prefabPool._spawned.Count > 0)
                {
                    if (prefabPool._spawned.Contains(prefab))
                    {
                        inst = prefab;
                        if (prefabPool.despawnMaxLimit != 0)
                        {
                            if (prefabPool._despawned.Count < prefabPool.despawnMaxLimit)
                            {
                                prefabPool._despawned.Add(inst);
                                if (inst.parent != transform)
                                {
                                    inst.SetParent(transform);
                                }
                                if (inst.localScale != prefabPool.prefabScale)
                                {
                                    inst.localScale = prefabPool.prefabScale;
                                }
                                inst.gameObject.SetActive(false);
                            }
                            else
                            {
                                Destroy(inst.gameObject);
                            }
                        }
                        else
                        {
                            prefabPool._despawned.Add(inst);
                            if (inst.parent != transform)
                            {
                                inst.SetParent(transform);
                            }
                            if (inst.localScale != prefabPool.prefabScale)
                            {
                                inst.localScale = prefabPool.prefabScale;
                            }
                            inst.gameObject.SetActive(false);
                        }

                        prefabPool._spawned.Remove(inst);
                    }
                }

                break;
            }
        }
        if (inst == null) return;

        _spawned.Remove(inst);
    }

    /// <summary>
    /// 销毁对象，销毁最不常用的对象
    /// </summary>
    /// <param name="prefabName">对象名字</param>
    public void Despawn(string prefabName)
    {
        Transform inst = null;

        for (int i = 0; i < _prefabPools.Count; i++)
        {
            PrefabPool prefabPool = _prefabPools[i];
            if (prefabPool.prefab.name == prefabName)
            {
                if (prefabPool._spawned.Count > 0)
                {
                    inst = prefabPool._spawned[0];
                    if (inst)
                    {
                        if (prefabPool.despawnMaxLimit != 0)
                        {
                            if (prefabPool._despawned.Count < prefabPool.despawnMaxLimit)
                            {
                                prefabPool._despawned.Add(inst);
                                if (inst.parent != transform)
                                {
                                    inst.SetParent(transform);
                                }
                                if (inst.localScale != prefabPool.prefabScale)
                                {
                                    inst.localScale = prefabPool.prefabScale;
                                }
                                inst.gameObject.SetActive(false);
                            }
                            else
                            {
                                Destroy(inst.gameObject);
                            }
                        }
                        else
                        {
                            prefabPool._despawned.Add(inst);
                            if (inst.parent != transform)
                            {
                                inst.SetParent(transform);
                            }
                            if (inst.localScale != prefabPool.prefabScale)
                            {
                                inst.localScale = prefabPool.prefabScale;
                            }
                            inst.gameObject.SetActive(false);
                        }

                        prefabPool._spawned.Remove(inst);
                    }
                }

                break;
            }
        }
        if (inst == null) return;

        _spawned.Remove(inst);
    }

    /// <summary>
    /// 自动销毁对象
    /// </summary>
    /// <param name="inst"></param>
    /// <param name="autoDespawnTime"></param>
    /// <returns></returns>
    private IEnumerator AutoDespawn(Transform inst, float autoDespawnTime)
    {
        yield return new WaitForSeconds(autoDespawnTime);
        Despawn(inst);
    }

    /// <summary>
    /// 自动整理销毁对象列表
    /// </summary>
    /// <param name="prefabPool"></param>
    /// <returns></returns>
    private IEnumerator TidyDespawn(PrefabPool prefabPool)
    {
        yield return new WaitForSeconds(prefabPool.tidyDespawnTime);
        for (int i = 0; i < prefabPool.tidyCount; i++)
        {
            if (prefabPool._despawned.Count > prefabPool.tidyDespawnMinCount)
            {
                if (prefabPool._despawned[0])
                {
                    Destroy(prefabPool._despawned[0].gameObject);
                    prefabPool._despawned.RemoveAt(0);
                }
            }
            else
            {
                break;
            }
        }

        StartCoroutine(TidyDespawn(prefabPool));
    }

    /// <summary>
    /// 销毁所有对象
    /// </summary>
    public void DespawnAll()
    {
        for (int i = 0; i < _prefabPools.Count; i++)
        {
            PrefabPool prefabPool = _prefabPools[i];
            for (int j = 0; j < prefabPool._spawned.Count; j++)
            {
                Transform inst = prefabPool._spawned[j];
                if (inst)
                {
                    prefabPool._despawned.Add(inst);
                    if (inst.parent != transform)
                    {
                        inst.SetParent(transform);
                    }
                    if (inst.localScale != prefabPool.prefabScale)
                    {
                        inst.localScale = prefabPool.prefabScale;
                    }
                    inst.gameObject.SetActive(false);
                }
            }
            prefabPool._spawned.Clear();
        }
        _spawned.Clear();
    }

    /// <summary>
    /// 清空所有对象
    /// </summary>
    public void Clean()
    {
        StopAllCoroutines();
        for (int i = 0; i < _prefabPools.Count; i++)
        {
            PrefabPool prefabPool = _prefabPools[i];
            for (int j = 0; j < prefabPool._spawned.Count; j++)
            {
                Transform inst = prefabPool._spawned[j];
                if (inst)
                {
                    Destroy(inst.gameObject);
                }
            }
            prefabPool._spawned.Clear();

            for (int j = 0; j < prefabPool._despawned.Count; j++)
            {
                Transform inst = prefabPool._despawned[j];
                if (inst)
                {
                    Destroy(inst.gameObject);
                }
            }
            prefabPool._despawned.Clear();
        }
        _spawned.Clear();
    }

    #endregion
}

[System.Serializable]
public class PrefabPool
{
    public Transform prefab;//对象池对象
    public int initDespawnCount;//初始化数量
    public int spawnMaxLimit;//生成最多限制数量
    public float autoDespawnTime;//自动销毁时间，单位秒
    public int despawnMaxLimit;//销毁对象列表最多限制数量
    public float tidyDespawnTime;//自动整理销毁对象时间频率，单位秒
    public int tidyDespawnMinCount;//自动整理销毁对象列表最少限制数量
    public int tidyCount; //每次整理销毁对象数量

    [HideInInspector]
    public Vector3 prefabScale;//预设原大小，用于返回对象池重置大小

    public PrefabPool(){ }
    /// <summary>
    /// 初始化对象池
    /// </summary>
    /// <param name="prefab">对象</param>
    /// <param name="initDespawnCount">初始化隐藏的对象</param>
    /// <param name="spawnMaxLimit">生成最多限制数量</param>
    /// <param name="autoDespawnTime">自动销毁时间，单位秒</param>
    /// <param name="despawnMaxLimit">销毁对象列表最多限制数量</param>
    /// <param name="tidyDespawnTime">自动整理销毁对象时间频率，单位秒</param>
    /// <param name="despawnMinLimit">自动整理销毁对象列表最少限制数量</param>
    /// <param name="tidyCount">每次整理销毁对象数量</param>
    public PrefabPool(Transform prefab, int initDespawnCount = 0, int spawnMaxLimit = 0, float autoDespawnTime = 0, int despawnMaxLimit = 0,
        float tidyDespawnTime = 0, int despawnMinLimit = 0, int tidyCount = 0)
    {
        this.prefab = prefab;
        this.initDespawnCount = initDespawnCount;
        this.spawnMaxLimit = spawnMaxLimit;
        this.autoDespawnTime = autoDespawnTime;
        this.despawnMaxLimit = despawnMaxLimit;
        this.tidyDespawnTime = tidyDespawnTime;
        this.tidyDespawnMinCount = despawnMinLimit;
        this.tidyCount = tidyCount;
    }

    /// <summary>
    /// 生成的对象
    /// </summary>
    public List<Transform> _spawned = new List<Transform>();
    /// <summary>
    /// 销毁生成的对象
    /// </summary>
    public List<Transform> _despawned = new List<Transform>();
}

 

使用方式：

        ResManager.Load("GameObjects", "PoolItem", (go) => {
            if (PoolManager.CreatePool("Test"))
            {
                GameObject tr = go as GameObject;
                item = tr.transform;
                spawnPool = PoolManager.GetSpawnPool("Test");
                PrefabPool prefabPool = new PrefabPool(item, 10, 12, 0, 20, 5, 4, 3);
                spawnPool.AddPrefab(prefabPool);
            }
        });

XM肖牧
关注
专栏目录
UNITY性能优化⭐对象池的使用方法（Object Pooling）
星河造梦坊
01-11 3039
使用对象池（Object Pooling）
unity资源池管理插件PoolManager v7.0.1.unitypackage
09-08
unity资源池管理插件PoolManager v7.0.1.unitypackage
Unity PoolManager
xixihaha36524的专栏
03-17 449
http://www.xuanyusong.com/archives/2974  http://blog.csdn.net/henren555/article/details/42100881
【unity框架开发7】对象池的使用，如何封装一个对象池管理器
最新发布
向宇
10-06 1200
频繁创建和销毁对象会造成性能的开销。创建对象的时候，系统会为这个对象开辟一片新的空间。销毁对象的时候，这个对象会变成内存垃圾，当内存垃圾达到一定程度，就会触发垃圾回收机制（及GC），清理内存垃圾，由于此时在清理垃圾，所以程序有可能就会变卡。为了改善这个问题，我们就可以使用对象池。使用了它之后，程序的性能就能得到提升不那么容易变卡。
UnityVR--PoolManager--对象池1
唐小墨同学的博客
05-16 616
API：Instantiate创建、gameObject.CompareTag("标签")、UnityEvent()事件管理、ObjectPool（）对象池
PoolManager(Unity3D插件)
热门推荐
不忘初心 方得始终
12-18 1万+
1、为什么要用池 当一个预制需要一遍又一遍的实例，创建一个是更有效地，而不是摧毁它，重用它。这被称为“实例池'，在那里你从池中先来一个项目，只有创建新实例，如果没有可用的。最重要的是，destroy（）方法已经被报道的实例的最糟糕的部分/破坏模式，造成垃圾收集口吃（瞬间冻结每隔几秒钟）。池去除destroy（）方法完全。 在某些极端的情况下，你可能仍然要销毁的对象进行内存管理。 PoolMan
【Unity3D自学记录】PoolManager插件
虚拟世界
07-21 4335
前几天我在博客里面分享了为什么Unity实例化很慢的原因，并且也分享了一个缓存池的工具。有朋友给我留言说PoolManager插件非常好用，我抽空研究了一下确实很好用。PoolManager目前的最新版本是5.5.2 我有幸在网络上找到了破解版本，文章最后我会放出来不过还是希望大家支持正版嘿嘿。 PoolManager5 介绍： https://www.assetstore.unity3d.
unity3d PoolManager
06-29
动态管理object对象
PoolManager 7.0.1.unitypackage游戏对象池/缓存池性能优化插件
06-11
Unity3D资源 PoolManager 7.0.1 游戏对象池/缓存池性能优化插件 要求Unity2017.2.0或以上版本
unity的对象池PoolManager最新
03-21
Unity对象池PoolManager6.0最新版本Unity对象池PoolManager6.0最新版本Unity对象池PoolManager6.0最新版本Unity对象池PoolManager6.0最新版本
Unity PoolManager7.0.1
09-23
总的来说，掌握Unity对象池管理工具PoolManager 7.0.1对于提升游戏性能和降低资源消耗具有重要意义。通过实践和学习，开发者可以更好地控制游戏对象的生命周期，从而为玩家提供更流畅的游戏体验。
[Unity]对象缓存池PoolManager.rar
04-06
[Unity]对象缓存池PoolManager,2019版本以上
Unity最新版对象池插件 PoolManager 6.0.0
05-28
Unity3D最常用的对象池插件，简单易上手
Unity对象池PoolManager功能
weixin_30721077的博客
10-16 172
对象池的优点有很多博主以及大神都说到,优化了内存,解决了大量的内存消耗.. 对象池类: using System.Collections; using System.Collections.Generic; using UnityEngine; /// <summary> /// 对象池类 /// </summary> public cla...
Unity PoolManager v7.0.1.zip
06-30
轻松管理对象缓冲池，目前最新版本。unity对象池插件7.0版本,轻松实现对象池功能，功能强大！unity对象池插件7.0版本,轻松实现对象池功能，功能强大！
[Unity]PoolManager的基础使用以及应用
BuladeMian的博客，菜得抠脚，菜得真实
04-20 1777
建立对象池 代码新建对象池 using System.Collections; using System.Collections.Generic; using UnityEngine; using PathologicalGames; ... #region SpawnPool public SpawnPool pool_A; public SpawnPool pool_B; public SpawnPool pool_C; #endreg...
Unity 轻量级对象池管理器（下）
zhutou_的博客
06-03 345
需要查看有关该对象池的解析的，请跳转： Unity 轻量级对象池管理器（上） 上图右下角的ObjectPool文件夹中，主要实现了两个脚本，第一个是对象池管理器(ObjectPoolManager)，第二个是对象队列管理(ObjectPoolModel) 使用时只需要将ObjectPoolManager挂载在游戏场景中的某个对象中，并在场景中添加一个GameObjectPool空对象即可 ObjectPoolModel代码如下： using System.Collections; usi
UnityVR--PoolManager--对象池2
唐小墨同学的博客
05-19 803
本篇自己构建一个对象池管理器（Manager），实现对象池的创建、删除、加载资源等功能。在这个过程中，可以了解一个管理器Manager类该如何架构。
Unity 工具类 之 简单的对象池管理类 ObjectPoolManager 实现
仙魁XAN
01-19 972
Unity 工具类 之 简单的对象池管理类 ObjectPoolManager 实现 目录 Unity 工具类 之 简单的对象池管理类 ObjectPoolManager 实现 一、简单介绍 二、实现原理 三、注意事项 四、效果预览 五、实现步骤 六、关键代码 七、参考工程 八、参考资料 一、简单介绍 Unity 工具类，自己整理的一些游戏开发可能用到的模块，单...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值