将长生命周期对象和大对象池化

请记住最开始说的原则：对象要么立即回收要么一直存在。它们要么在0代被回收，要么在2代里一直存在。有些对象本质是静态的，生命周期从它们被创建开始，到程序停止才会结束。其它对象显然不需要永远存在下去，但他们的生命周期会存在程序的某些上下文里。它们的存活时间会超过0代（1代）回收。这些类型的对象可以作为池化对象的备选。这虽然需要你手动管理内存，但实际情况下这是一个很好的选择。另外一个重要的需要池化的对象是分配在LOH里的大对象。

没有一个单一的标准方案或者API来实现对象的池化。 这需要你根据你的程序和对象的类型来设计对应方案。

对于如何管理池化对象，你可以将其当做非托管资源（内存）来进行管理。.NET对于这类资源有一个种管理模式：IDisposable。在本章前面我们介绍了如何实现这种模式。一个比较合理的方式是实现IDisposable接口，在Dispose方法里将对象丢回对象池。
实现一个好的对象池策略并不简单，他取决于你程序要如何使用，以及那种类型的对象需要进行池化。
下面的栗子，实现了一个简单的对象池，你可以从里面知道对象池会涉及那些内容。这个代码可以从 PooledObjects 的栗子工程里看到。

    interface IPoolableObject : IDisposable
    {
        int Size { get; }
        void Reset();
        void SetPoolManager(PoolManager poolManager);
    }

    internal class PoolManager
    {
        private class Pool
        {
            public int PooledSize { get; set; }

            public int Count
            {
                get { return this.Stack.Count; }
            }

            public Stack<IPoolableObject> Stack { get; private set; }

            public Pool()
            {
                this.Stack = new Stack<IPoolableObject>();
            }
        }

        private const int MaxSizePerType = 10*(1 << 10); // 10 MB 

        private Dictionary<Type, Pool> pools = new Dictionary<Type, Pool>();

        public int TotalCount
        {
            get
            {
                int sum = 0;
                foreach (var pool in this.pools.Values)
                {
                    sum += pool.Count;
                }
                return sum;
            }
        }

        public T GetObject<T>() where T : class, IPoolableObject, new()
        {
            Pool pool;
            T valueToReturn = null;
            if (pools.TryGetValue(typeof (T), out pool))
            {
                if (pool.Stack.Count > 0)
                {
                    valueToReturn = pool.Stack.Pop() as T;
                }
            }
            if (valueToReturn == null)
            {
                valueToReturn = new T();
            }
            valueToReturn.SetPoolManager(this);
            return valueToReturn;
        }

        public void ReturnObject<T>(T value) where T : class, IPoolableObject, new()
        {
            Pool pool;
            if (!pools.TryGetValue(typeof (T), out pool))
            {
                pool = new Pool();
                pools[typeof (T)] = pool;
            }
            if (value.Size + pool.PooledSize < MaxSizePerType)
            {
                pool.PooledSize += value.Size;
                value.Reset();
                pool.Stack.Push(value);
            }
        }
    }

    internal class MyObject : IPoolableObject
    {
        private PoolManager poolManager;
        public byte[] Data { get; set; }
        public int UsableLength { get; set; }

        public int Size
        {
            get { return Data != null ? Data.Length : 0; }
        }

        void IPoolableObject.Reset()
        {
            UsableLength = 0;
        }

        void IPoolableObject.SetPoolManager(PoolManager poolManager)
        {
            this.poolManager = poolManager;
        }

        public void Dispose()
        {
            this.poolManager.ReturnObject(this);
        }
    }

强制让每个对象都实现接口会麻烦一些，但它除了方便外，还有一个重要的事实：为了使对象池重用对象，你必须能完全理解并控制它们。每次对象回到对象池前，你的代码需要将对象重新设置到一个移植的，安全的状态。这意味着你不应该天真的直接用第三方的对象池组件。你需要设计接口，并让对象实现该接口，用来处理每个对象获取时的初始化过程。你还需要特别小心对.NET框架对象做池化。

特别需要注意的是用来做对象池的集合，因为它们的性质决定--你并不希望它们销毁所存储的数据（毕竟这是池的重点），但你需要一个可以表示可以为空和可用空间的集合。幸运的是，大多数集合类型都实现了长度和容量的参数。考虑到使用现有的.NET集合类型会存在风险，建议最好自己实现集合类型，并实现一些标准的集合接口（如：IList ,ICollection 等）。相关创建自己定义集合的内容，可参考本书第六章。另外一个策略就是让你设计的可回收对象实现一个终结器（析构函数）。如果终结器运行，则意味着Dispose方法没有执行，这将会是一个小小的bug。你也可以在你的程序里一些地方记录日志，崩溃信息或者一些信号信息。

请牢记，如果不清理对象池里的数据，这等同于内存泄漏。你的对象池应该有一个边界大小（无论是字节数量或者对象的数量），一旦超过，它应该通知GC清理多余的对象。理想情况下，你的对象池足够大，可以正常操作而不回收对象，但也会造成GC在执行回收时暂停时间变长，对象池里对象越多回收算法耗时也越多。当然最重要的还是对象池能满足你的需要。

我通常不会将对象池作为默认的解决方案。它作为一种通用机制，显得很笨重以及容易出错。但你可能会发现你的程序在某些类型上很适用对象池。在一个应用里分配了大量的LOH对象，我们调查后发现，可以将一个单一的对象池化就能解决99%的问题。这个就是MemoryStream，我们使用它来序列化网络传输数据。实际的实现不仅仅是将构建了一个MemoryStream的队列，因为要避免内存碎片，有一些更复杂的设计，但从本质上来说还是将它池化。每次使用完