UGUI中的obejectpool＜T＞以及listpool＜T＞

UGUI源码中的对象池类源码(objectpool)

//T 泛型，传入的类型，可以是任意类型(但必须满足泛型约束：new()),T是对象池管理的类型
internal class ObjectPool<T> where T : new()
    {
       //用一个栈来进行内部实现
        private readonly Stack<T> m_Stack = new Stack<T>();
        //向对象池里取T类型的元素的时候的回调
        private readonly UnityAction<T> m_ActionOnGet;
        //向对象池里放T类型元素的时候回调，两个回调都在该类构造的时候初始化
        private readonly UnityAction<T> m_ActionOnRelease;
       //当前再用以及池里面放到所有T类型的元素的和
        public int countAll { get; private set; }
        //从池里面取出，当前在用的元素个数
        public int countActive { get { return countAll - countInactive; } }
        //池中的T类型元素个数
        public int countInactive { get { return m_Stack.Count; } }
     
        public ObjectPool(UnityAction<T> actionOnGet, UnityAction<T> actionOnRelease)
        {
            m_ActionOnGet = actionOnGet;
            m_ActionOnRelease = actionOnRelease;
        }
       //从对象池里往外取
        public T Get()
        {
            T element;
            //池里面没有，实例化一个
            if (m_Stack.Count == 0)
            {
                element = new T();
                countAll++;
            }
            //有，直接把池里这个拿出去
            else
            {
                element = m_Stack.Pop();
            }
            //取出这个T类型元素时的回调，执行该回调
            if (m_ActionOnGet != null)
                m_ActionOnGet(element);
            return element;
        }
        

        public void Release(T element)
        {
            //该T类型的元素以及放进池中里了，报错
            if (m_Stack.Count > 0 && ReferenceEquals(m_Stack.Peek(), element))
                Debug.LogError("Internal error. Trying to destroy object that is already released to pool.");
            //放进池子时的回调
            if (m_ActionOnRelease != null)
                m_ActionOnRelease(element);
            m_Stack.Push(element);
        }
    }

UGUI中基于objectpool实现的listpool

internal static class ListPool<T>
    {
        // Object pool to avoid allocations.
        //池子里复用的元素类型是list<T>,t根据传入的泛型类型而定
        //往池子里放list<T>类型元素时的回调是clear,每次往池子里放list就清空list
        private static readonly ObjectPool<List<T>> s_ListPool = new ObjectPool<List<T>>(null, Clear);
        static void Clear(List<T> l) { l.Clear(); }

        public static List<T> Get()
        {
            return s_ListPool.Get();
        }

        public static void Release(List<T> toRelease)
        {
            s_ListPool.Release(toRelease);
        }
    }