Gameframework(Reference Pool初探篇)

前言

可能刚学编程的会不知道引用类型和值类型是什么意思？导致可能会不明白框架给出的引用池到底是什么用来干嘛的，为什么创建对象必须调用引用池给出的接口Acquire函数，才会对游戏性能有所优化。

1.值类型和引用类型区别

在我们学习Gameframework的引用池之前，先要详细了解一下值类型和引用类型的概念，这里就和各位简单的介绍一下，值类型保存在栈上，引用类型保存在堆上。就这么多了，大家可以出门右转了（这样说好像有点过分了😜），所以还是准备介绍清楚点，值类型的是int、char、float、struct，引用类型是string、class，值类型的性能比引用类型好很多，所以考虑性能方面的时候，并且不需要继承，偏向于数据的组合。我们就可以使用结构体去替换类的实现，可能大家会思考为什么值类型就比引用类型块？

因为值类型在栈上的，可以直接获取使用，而引用类型在栈上存了一个指向堆地址的变量，如果你要访问引用类型的变量时，它会先去获取到地址，通过这个地址去访问堆上的数据，给大家图解一下：

哇·咔咔，在下画的图简直不要太强，简简单单就解决了各位的疑惑（强行自我吹嘘一波）， C#其实可以靠以下代码去判断此对象到底是值类型还是引用类型，具体代码如下：

    if(xxx.GetType().IsValueType)
    {
        Console.Write("值类型");
    }
    else
    {
        Console.Write("引用类型");
    }

还有值类型出作用域以后就会自动释放（其实不是释放，算是指针往下移，新数据直接往上覆盖的），所以值类型是按照顺序去控制释放的，引用类型对象虽然也是保存在栈上，然后也是按照顺序释放的。但是指向的堆上的数据是靠GC去控制的，具体的垃圾回收机制传送门:https://blog.csdn.net/m0_37920739/article/details/103745310 

2.引用池讲解

引用池设计出来的目的是防止堆上数据频繁的创建和释放，从而达到优化游戏的。一般情况下如果引用对象出作用域以后，栈上的地址就会被移除掉，但是堆上的占用的空间会等待C#的GC机制去控制释放，这里所谓的引用池子就是字典，Key是类Type，Value是引用类型队列和其他参数，具体代码如下：

//作为引用池的字典
        private static readonly Dictionary<Type, ReferenceCollection> s_ReferenceCollections = new Dictionary<Type, ReferenceCollection>();


//字典的Value
        private sealed class ReferenceCollection
        {
            private readonly Queue<IReference> m_References;
            private readonly Type m_ReferenceType;
            private int m_UsingReferenceCount;
            private int m_AcquireReferenceCount;
            private int m_ReleaseReferenceCount;
            private int m_AddReferenceCount;
            private int m_RemoveReferenceCount;

            public ReferenceCollection(Type referenceType)
            {
                m_References = new Queue<IReference>();
                m_ReferenceType = referenceType;
                m_UsingReferenceCount = 0;
                m_AcquireReferenceCount = 0;
                m_ReleaseReferenceCount = 0;
                m_AddReferenceCount = 0;
                m_RemoveReferenceCount = 0;
            }

            public Type ReferenceType
            {
                get
                {
                    return m_ReferenceType;
                }
            }

            public int UnusedReferenceCount
            {
                get
                {
                    return m_References.Count;
                }
            }

            public int UsingReferenceCount
            {
                get
                {
                    return m_UsingReferenceCount;
                }
            }

            public int AcquireReferenceCount
            {
                get
                {
                    return m_AcquireReferenceCount;
                }
            }

            public int ReleaseReferenceCount
            {
                get
                {
                    return m_ReleaseReferenceCount;
                }
            }

            public int AddReferenceCount
            {
                get
                {
                    return m_AddReferenceCount;
                }
            }

            public int RemoveReferenceCount
            {
                get
                {
                    return m_RemoveReferenceCount;
                }
            }

            public T Acquire<T>() where T : class, IReference, new()
            {
                if (typeof(T) != m_ReferenceType)
                {
                    throw new GameFrameworkException("Type is invalid.");
                }

                m_UsingReferenceCount++;
                m_AcquireReferenceCount++;
                lock (m_References)
                {
                    if (m_References.Count > 0)
                    {
                        return (T)m_References.Dequeue();
                    }
                }

                m_AddReferenceCount++;
                return new T();
            }

            public IReference Acquire()
            {
                m_UsingReferenceCount++;
                m_AcquireReferenceCount++;
                lock (m_References)
                {
                    if (m_References.Count > 0)
                    {
                        return m_References.Dequeue();
                    }
                }

                m_AddReferenceCount++;
                return (IReference)Activator.CreateInstance(m_ReferenceType);
            }

            public void Release(IReference reference)
            {
                reference.Clear();
                lock (m_References)
                {
                    if (m_EnableStrictCheck && m_References.Contains(reference))
                    {
                        throw new GameFrameworkException("The reference has been released.");
                    }

                    m_References.Enqueue(reference);
                }

                m_ReleaseReferenceCount++;
                m_UsingReferenceCount--;
            }

            public void Add<T>(int count) where T : class, IReference, new()
            {
                if (typeof(T) != m_ReferenceType)
                {
                    throw new GameFrameworkException("Type is invalid.");
                }

                lock (m_References)
                {
                    m_AddReferenceCount += count;
                    while (count-- > 0)
                    {
                        m_References.Enqueue(new T());
                    }
                }
            }

            public void Add(int count)
            {
                lock (m_References)
                {
                    m_AddReferenceCount += count;
                    while (count-- > 0)
                    {
                        m_References.Enqueue((IReference)Activator.CreateInstance(m_ReferenceType));
                    }
                }
            }

            public void Remove(int count)
            {
                lock (m_References)
                {
                    if (count > m_References.Count)
                    {
                        count = m_References.Count;
                    }

                    m_RemoveReferenceCount += count;
                    while (count-- > 0)
                    {
                        m_References.Dequeue();
                    }
                }
            }

            public void RemoveAll()
            {
                lock (m_References)
                {
                    m_RemoveReferenceCount += m_References.Count;
                    m_References.Clear();
                }
            }
        }

看到Value里的队列(Queue<IReference>)，我们就知道会有限制了，要使用这个引用池组件的引用类型必须要继承IReference接口，然后才可以通过Acquire函数去获取对象，其实看到Acquire函数之后，我们就会知道限制的不单单是要继承IReference接口，还必须要是引用类型和类要包含无参构造函数，具体代码如下:

        public static T Acquire<T>() where T : class, IReference, new()
        {
            return GetReferenceCollection(typeof(T)).Acquire<T>();
        }

各位如果很少用到这种写法，而不知具体什么意思的话，这里给大家整理出了一个表格，用来简述一下写法功能。

约束	描述
where T: struct	此类型参数必须是值类型，除了Nullable类型的所有类型都可以。
where T: class	此类型参数必须是引用类型。
where T: new()	此类型参数必须有一个公有的无参构造函数。当和其它约束参数一起使用时，new()约束必须放在最后。
where T:base	此类型参数必须是或者继承自指定的基类。
where T:interface	此类型参数必须是或者实现了指定的接口。
where T: U	类型参数T必须是或者继承于类型参数。

大概的意思就是通过函数获取引用类型时，如果没有这个引用类型将会去创建出这个引用类型，如果存在这个引用类型而且有多余的引用类型可使用，就返回保存在队列里的引用类型(只不过使用对象时需要重新初始化的)，但是用着感觉就是限制太多了，又要继承指定接口，又要必须含有无参构造函数等等，作为一个尊崇着自由的单身狗，实在用着有点不喜欢，所以准备在引用池进阶篇里准备想办法调整这个模块，这里就不和各位扩展了。接下来看一下ReferencePoolComponent组件有什么参数暴露出来给用户，只发现了Enable Strict Check选项，如图所示：

这个值具体什么意思呢？查看对应的代码就可以知道了， 这个值主要是用来判断是否要检查引用类型是否规范的，如果引用类型异常会抛出异常，一般建议发布正式版本时选择Always Disable选项，其他场合就把它一直开着方便查看报错，易于调式。