unity之性能优化 对象池之【类对象池】

对象池老生常谈的问题了，对象池即对象的池子。大概描述下：对象池内寄放着废弃的对象，当程序需要某对象去池子里拿，让废弃对象再利用，如果没有则创建；用完之后再将废弃的对象回收。一句话：让内存重复利用的优化方案。

解决痛点：

1.省去很多内存碎片得问题；

2.节省实例对CPU的消耗；

3.触发垃圾回收(GC)的次数少了。

注意事项：

在场景切换的时候，要销毁整个对象池，避免无意义内存驻留。

废话说完了，先上图：

 思路是这样的：

按C键进行取池（去池子里面拿），按D键进行回池（对象回收），常驻数量：设置池中对象数量保持多少不进行释放，没有设置则进行释放。这里设置的是3秒自动释放池中对象。

 

代码如下：

类对象池：

using System;
using System.Collections.Generic;

/// <summary>
/// 类对象池
/// </summary>
public class TestClassObjectPool : IDisposable
{
    /// <summary>
    /// key 类型哈希码
    /// </summary>
    private readonly Dictionary<int, Queue<object>> m_Pools;

    /// <summary>
    /// 常驻
    /// </summary>
    public readonly Dictionary<int, byte> ResidentDic;


#if UNITY_EDITOR
    /// <summary>
    /// 编辑器面板监控用的
    /// </summary>
    public readonly Dictionary<Type, int> InspectorDic;
#endif


    public TestClassObjectPool()
    {
        m_Pools = new Dictionary<int, Queue<object>>();
        ResidentDic = new Dictionary<int, byte>();
#if UNITY_EDITOR
        InspectorDic = new Dictionary<Type, int>();
#endif
    }

    /// <summary>
    /// 取池
    /// </summary>
    internal T Dequeue<T>() where T : class, new()
    {
        lock (m_Pools)
        {
            int key = typeof(T).GetHashCode();
            m_Pools.TryGetValue(key, out Queue<object> queueList);
            if (queueList == null)
            {
                queueList = new Queue<object>();
                m_Pools[key] = queueList;
            }
            else
            {
                if (queueList.Count > 0)
                {
                    UnityEngine.Debug.LogError("池中存在对象 取出一个");
#if UNITY_EDITOR
                    InspectorDic.TryGetValue(typeof(T), out int count);
                    count = count > 0 ? --count : 0;
                    InspectorDic[typeof(T)] = count;
#endif
                    return (T)queueList.Dequeue();
                }
            }
            UnityEngine.Debug.LogError("对象不存在 进行创建");
            return new T();
        }
    }

    /// <summary>
    /// 回池
    /// </summary>
    internal void Equeue(object obj)
    {
        lock (m_Pools)
        {
            int key = obj.GetType().GetHashCode();
            m_Pools.TryGetValue(key, out Queue<object> queueList);
            if (queueList != null)
            {
                queueList.Enqueue(obj);
#if UNITY_EDITOR
                InspectorDic.TryGetValue(obj.GetType(), out int count);
                count++;
                InspectorDic[obj.GetType()] = count;
#endif
                UnityEngine.Debug.LogError("对象回池了");
            }
        }
    }

    /// <summary>
    /// 常驻
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="count"></param>
    internal void SetResident<T>(byte count) where T : class
    {
        lock (m_Pools)
        {
            int key = typeof(T).GetHashCode();
            if (!ResidentDic.ContainsKey(key))
            {
                ResidentDic[key] = count;
            }
        }
    }

    internal void ClearPool()
    {
        var vr = m_Pools.GetEnumerator();
        while (vr.MoveNext())
        {
            ResidentDic.TryGetValue(vr.Current.Key, out byte count);
            Queue<object> queue = vr.Current.Value;
            if (queue.Count > count)
            {
                object obj = queue.Dequeue();
#if UNITY_EDITOR
                InspectorDic.TryGetValue(obj.GetType(), out int insCount);
                insCount--;
                InspectorDic[obj.GetType()] = insCount;
                if (queue.Count == 0)
                {
                    InspectorDic.Remove(obj.GetType());
                }
#endif                          
            }
        }
    }

    public void Dispose()
    {
        m_Pools.Clear();
    }

}

对象池管理器：

using System;
using UnityEngine;

/// <summary>
/// 对象池管理器
/// </summary>
public class TestPoolManager : IDisposable
{
    /// <summary>
    /// 下次运行时间 
    /// </summary>
    private float m_NextRunTime = 0;

    /// <summary>
    /// 释放间隔
    /// </summary>
    private float ClearInterval = 3;

    public TestClassObjectPool ClassPool { get; private set; }
    public TestPoolManager()
    {
        ClassPool = new TestClassObjectPool();
        m_NextRunTime = Time.time;
    }

    internal void Init()
    {
    }

    public void OnUpdate()
    {
        if (Time.time > m_NextRunTime + ClearInterval)
        {
            m_NextRunTime = Time.time;
            ClassPool.ClearPool();
        }
    }

    public void Dispose()
    {
        ClassPool.Dispose();
    }
}

 

游戏入口：

using UnityEngine;

public class TestGameEntry : MonoBehaviour
{
    public static TestGameEntry Instance;
    public static TestTimeManager TimeMgr { get; private set; }
    public static TestPoolManager PoolMgr { get; private set; }

    private void Awake()
    {
        Instance = this;
    }

    void Start()
    {
        InitManagers();
        Init();
    }

    void InitManagers()
    {
        TimeMgr = new TestTimeManager();
        PoolMgr = new TestPoolManager();
    }

    void Init()
    {
        TimeMgr.Init();
        PoolMgr.Init();
    }

    void Update()
    {
        TimeMgr.OnUpdate();
        PoolMgr.OnUpdate();
    }

    private void OnDestroy()
    {
        TimeMgr.Dispose();
        PoolMgr.Dispose();
    }
}

 

编辑器拓展：

using UnityEditor;
using UnityEngine;

[CustomEditor(typeof(TestGameEntry))]
public class TestPoolManagerInspector : Editor
{
    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();
        serializedObject.Update();//实时刷新
        GUILayout.Space(10);
        GUILayout.BeginVertical("box");
        GUILayout.BeginHorizontal("box");
        GUILayout.Space(20);
        GUILayout.Label("类对象");
        GUILayout.Label("池中数量");
        GUILayout.Label("常驻数量");
        GUILayout.EndHorizontal();
        if (TestGameEntry.PoolMgr != null)
        {
            var insEnumerator = TestGameEntry.PoolMgr.ClassPool.InspectorDic.GetEnumerator();
            while (insEnumerator.MoveNext())
            {
                GUILayout.BeginHorizontal("box");
                GUILayout.Label(insEnumerator.Current.Key.Name, GUILayout.Width(100));
                GUILayout.Label(insEnumerator.Current.Value.ToString(), GUILayout.Width(60));
                TestGameEntry.PoolMgr.ClassPool.ResidentDic.TryGetValue(insEnumerator.Current.Key.GetHashCode(), out byte residentCount);
                GUILayout.Label(residentCount.ToString(), GUILayout.Width(80));
                GUILayout.EndHorizontal();
            }
        }
        GUILayout.EndVertical();
        serializedObject.Update();
        Repaint();//重绘
    }
}

 

测试用例：

using UnityEngine;

public class userData
{
}

public class userData11
{
}

public class TestPool_2 : MonoBehaviour
{
    System.Text.StringBuilder sb = null;
    userData aa = null;
    userData11 aa11 = null;

    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.C))
        {
            Debug.Log("按了C键 --------");
            sb = TestGameEntry.PoolMgr.ClassPool.Dequeue<System.Text.StringBuilder>();  //new System.Text.StringBuilder();            
            TestGameEntry.PoolMgr.ClassPool.SetResident<System.Text.StringBuilder>(2);
            sb.Length = 0;
            sb.Append("111");
            Debug.Log(sb.ToString());

            aa = TestGameEntry.PoolMgr.ClassPool.Dequeue<userData>();
            TestGameEntry.PoolMgr.ClassPool.SetResident<userData>(1);
            aa11 = TestGameEntry.PoolMgr.ClassPool.Dequeue<userData11>();
        }

        if (Input.GetKeyDown(KeyCode.D))
        {
            if (sb == null) return;
            Debug.Log("按了D键 ========== ");
            TestGameEntry.PoolMgr.ClassPool.Equeue(sb);
            TestGameEntry.PoolMgr.ClassPool.Equeue(aa);
            TestGameEntry.PoolMgr.ClassPool.Equeue(aa11);
        }
    }
}

 

欢迎大家提出批评建议和指教哈~