对象池的实现

• 比较简洁的对象池

using System;

namespace ZSLib.ZStudio
{
    public sealed class ObjectPool<T> where T : new ()
    {
        /// <summary>
        /// 如果需要可以增加数组的数量
        /// </summary>
        private int growSize = 20;

        /// <summary>
        /// 池对象
        /// </summary>
        private T[] pool;

        /// <summary>
        /// 指向池中元素的索引
        /// </summary>
        private int nextUnuseIndex = 0;

        public ObjectPool(int size)
        {
            Resize(size, false);
        }

        public ObjectPool(int size, int growSize)
        {
            this.growSize = growSize;
            Resize(size, false);
        }

        /// <summary>
        /// 池的总大小
        /// </summary>
        public int Length
        {
            get { return pool.Length; }
        }
        
        /// <summary>
        /// 池中可使用的对象
        /// </summary>
        public int Available
        {
            get { return pool.Length - nextUnuseIndex; }
        }
        
        /// <summary>
        /// 池中已经分配使用对象的数量
        /// </summary>
        public int Spawned
        {
            get { return nextUnuseIndex; }
        }

        public T Spawn()
        {
            T inst = default(T);
            
            // 如果需要扩大池的大小
            if (nextUnuseIndex >= pool.Length)
            {
                if (growSize > 0) Resize(pool.Length + growSize, true);
                // 无法扩大池返回default(T)-null
                else return inst;
            }

            if (nextUnuseIndex >= 0 && nextUnuseIndex < pool.Length)
            {
                inst = pool[nextUnuseIndex];
                nextUnuseIndex++;
            }

            return inst;
        }
        
        public void Despawn(T inst)
        {
            if (nextUnuseIndex > 0)
            {
                nextUnuseIndex--;
                pool[nextUnuseIndex] = inst;
            }
        }
        
        /// <summary>
        /// 快速重建池
        /// </summary>
        public void Reset()
        {
            int len = growSize;
            if (pool != null) len = pool.Length;
            
            Resize(len, false);
            nextUnuseIndex = 0;
        }
        
        /// <summary>
        /// 调整池的大小
        /// </summary>
        /// <param name="size">新的大小</param>
        /// <param name="copyExisting">使用原有的元素</param>
        public void Resize(int size, bool copyExisting)
        {
            // 提供多线程支持
            lock (this)
            {
                int count = 0;
                T[] newPool = new T[size];
                if (pool != null && copyExisting)
                {
                    count = pool.Length;
                    Buffer.BlockCopy(pool, 0, newPool, 0, Math.Min(count, size));
                }

                // 为新增加的对象初始化
                for (int i = count; i < size; i++)
                {
                    newPool[i] = new T();
                }

                pool = newPool;
            }
        }
    }
}

• 工厂模式的对象池<请参阅考Zenject>

using System;
namespace Zenject
{
    public interface IMemoryPool
    {
        int NumTotal { get; }
        int NumActive { get; }
        int NumInactive { get; }

        Type ItemType
        {
            get;
        }
    }

    public interface IMemoryPool<TValue> : IMemoryPool
    {
        TValue Spawn();
        void Despawn(TValue item);
    }

    public interface IMemoryPool<in TParam1, TValue> : IMemoryPool
    {
        TValue Spawn(TParam1 param);
        void Despawn(TValue item);
    }

    public interface IMemoryPool<in TParam1, in TParam2, TValue> : IMemoryPool
    {
        TValue Spawn(TParam1 param1, TParam2 param2);
        void Despawn(TValue item);
    }

    public interface IMemoryPool<in TParam1, in TParam2, in TParam3, TValue> : IMemoryPool
    {
        TValue Spawn(TParam1 param1, TParam2 param2, TParam3 param3);
        void Despawn(TValue item);
    }

    public interface IMemoryPool<in TParam1, in TParam2, in TParam3, in TParam4, TValue> : IMemoryPool
    {
        TValue Spawn(TParam1 param1, TParam2 param2, TParam3 param3, TParam4 param4);
        void Despawn(TValue item);
    }

    public interface IMemoryPool<in TParam1, in TParam2, in TParam3, in TParam4, in TParam5, TValue> : IMemoryPool
    {
        TValue Spawn(TParam1 param1, TParam2 param2, TParam3 param3, TParam4 param4, TParam5 param5);
        void Despawn(TValue item);
    }
}

using System;
using System.Collections.Generic;
using ModestTree;

namespace Zenject
{
    // Zero parameters
    public class MemoryPool<TValue> : MemoryPoolBase<TValue>, IMemoryPool<TValue>
    {
        public TValue Spawn()
        {
            var item = GetInternal();
            Reinitialize(item);
            return item;
        }

        protected virtual void Reinitialize(TValue item)
        {
            // Optional
        }
    }

    // One parameter
    public class MemoryPool<TParam1, TValue>
        : MemoryPoolBase<TValue>, IMemoryPool<TParam1, TValue>
    {
        public TValue Spawn(TParam1 param)
        {
            var item = GetInternal();
            Reinitialize(param, item);
            return item;
        }

        protected virtual void Reinitialize(TParam1 p1, TValue item)
        {
            // Optional
        }
    }

    // Two parameters
    public class MemoryPool<TParam1, TParam2, TValue>
        : MemoryPoolBase<TValue>, IMemoryPool<TParam1, TParam2, TValue>
    {
        public TValue Spawn(TParam1 param1, TParam2 param2)
        {
            var item = GetInternal();
            Reinitialize(param1, param2, item);
            return item;
        }

        protected virtual void Reinitialize(TParam1 p1, TParam2 p2, TValue item)
        {
            // Optional
        }
    }

    // Three parameters
    public class MemoryPool<TParam1, TParam2, TParam3, TValue>
        : MemoryPoolBase<TValue>, IMemoryPool<TParam1, TParam2, TParam3, TValue>
    {
        public TValue Spawn(TParam1 param1, TParam2 param2, TParam3 param3)
        {
            var item = GetInternal();
            Reinitialize(param1, param2, param3, item);
            return item;
        }

        protected virtual void Reinitialize(TParam1 p1, TParam2 p2, TParam3 p3, TValue item)
        {
            // Optional
        }
    }

    // Four parameters
    public class MemoryPool<TParam1, TParam2, TParam3, TParam4, TValue>
        : MemoryPoolBase<TValue>, IMemoryPool<TParam1, TParam2, TParam3, TParam4, TValue>
    {
        public TValue Spawn(TParam1 param1, TParam2 param2, TParam3 param3, TParam4 param4)
        {
            var item = GetInternal();
            Reinitialize(param1, param2, param3, param4, item);
            return item;
        }

        protected virtual void Reinitialize(TParam1 p1, TParam2 p2, TParam3 p3, TParam4 p4, TValue item)
        {
            // Optional
        }
    }

    // Five parameters
    public class MemoryPool<TParam1, TParam2, TParam3, TParam4, TParam5, TValue>
        : MemoryPoolBase<TValue>, IMemoryPool<TParam1, TParam2, TParam3, TParam4, TParam5, TValue>
    {
        public TValue Spawn(
            TParam1 param1, TParam2 param2, TParam3 param3, TParam4 param4, TParam5 param5)
        {
            var item = GetInternal();
            Reinitialize(param1, param2, param3, param4, param5, item);
            return item;
        }

        protected virtual void Reinitialize(TParam1 p1, TParam2 p2, TParam3 p3, TParam4 p4, TParam5 p5, TValue item)
        {
            // Optional
        }
    }
}

public class Foo
{
    public class Pool : MemoryPool<Foo>
    {
    }
}

public class Bar
{
    readonly Foo.Pool _fooPool;
    readonly List<Foo> _foos = new List<Foo>();

    public Bar(Foo.Pool fooPool)
    {
        _fooPool = fooPool;
    }

    public void AddFoo()
    {
        _foos.Add(_fooPool.Spawn());
    }

    public void RemoveFoo()
    {
        var foo = _foos[0];
        _fooPool.Despawn(foo);
        _foos.Remove(foo);
    }
}

public class TestInstaller : MonoInstaller<TestInstaller>
{
    public override void InstallBindings()
    {
        Container.Bind<Bar>().AsSingle();
        Container.BindMemoryPool<Foo, Foo.Pool>();
    }
}

当然也是可以抛开D/I框架来使用的.