設計模式之美：Object Pool（對象池）

索引

• 意圖
• 結構
• 參與者
• 適用性
• 效果
• 相關模式
• 實現
  • 實現方式（一）：實現 DatabaseConnectionPool 類。
  • 實現方式（二）：使用對象構造方法和預分配方式實現 ObjectPool 類。

意圖

運用對象池化技術可以顯著地提升性能，尤其是當對象的初始化過程代價較大或者頻率較高時。

Object pooling can offer a significant performance boost; it is most effective in situations where the cost of initializing a class instance is high, the rate of instantiation of a class is high.

結構

參與者

Reusable

• 類的實例與其他對象進行有限時間的交互。

ReusablePool

• 管理類的實例。

Client

• 使用類的實例。

適用性

當以下情況成立時可以使用 Object Pool 模式：

• 類的實例可重用於交互。
• 類的實例化過程開銷較大。
• 類的實例化的頻率較高。
• 類參與交互的時間周期有限。

效果

• 節省了創建類的實例的開銷。
• 節省了創建類的實例的時間。
• 存儲空間隨着對象的增多而增大。

相關模式

• 通常，可以使用 Singleton 模式實現 ReusablePool 類。
• Factory Method 模式封裝了對象的創建的過程，但其不負責管理對象。Object Pool 負責管理對象。

實現

實現方式（一）：實現 DatabaseConnectionPool 類。

如果 Client 調用 ObjectPool 的 AcquireReusable() 方法來獲取 Reusable 對象，當在 ObjectPool 中存在可用的 Reusable 對象時，其將一個 Reusable 從池中移除，然后返回該對象。如果池為空，則 ObjectPool 會創建一個新的 Reusable 對象。

namespace ObjectPoolPattern.Implementation1
{
  public abstract class ObjectPool<T>
  {
    private TimeSpan _expirationTime;
    private Dictionary<T, DateTime> _unlocked;
    private Dictionary<T, DateTime> _locked;
    private readonly object _sync = new object();

    public ObjectPool()
    {
      _expirationTime = TimeSpan.FromSeconds(30);
      _locked = new Dictionary<T, DateTime>();
      _unlocked = new Dictionary<T, DateTime>();
    }

    public ObjectPool(TimeSpan expirationTime)
      : this()
    {
      _expirationTime = expirationTime;
    }

    protected abstract T Create();

    public abstract bool Validate(T reusable);

    public abstract void Expire(T reusable);

    public T CheckOut()
    {
      lock (_sync)
      {
        T reusable = default(T);

        if (_unlocked.Count > 0)
        {
          foreach (var item in _unlocked)
          {
            if ((DateTime.UtcNow - item.Value) > _expirationTime)
            {
              // object has expired
              _unlocked.Remove(item.Key);
              Expire(item.Key);
            }
            else
            {
              if (Validate(item.Key))
              {
                // find a reusable object
                _unlocked.Remove(item.Key);
                _locked.Add(item.Key, DateTime.UtcNow);
                reusable = item.Key;
                break;
              }
              else
              {
                // object failed validation
                _unlocked.Remove(item.Key);
                Expire(item.Key);
              }
            }
          }
        }

        // no object available, create a new one
        if (reusable == null)
        {
          reusable = Create();
          _locked.Add(reusable, DateTime.UtcNow);
        }

        return reusable;
      }
    }

    public void CheckIn(T reusable)
    {
      lock (_sync)
      {
        _locked.Remove(reusable);
        _unlocked.Add(reusable, DateTime.UtcNow);
      }
    }
  }

  public class DatabaseConnection : IDisposable
  {
    // do some heavy works
    public DatabaseConnection(string connectionString)
    {
    }

    public bool IsOpen { get; set; }

    // release something
    public void Dispose()
    {
    }
  }

  public class DatabaseConnectionPool : ObjectPool<DatabaseConnection>
  {
    private string _connectionString;

    public DatabaseConnectionPool(string connectionString)
      : base(TimeSpan.FromMinutes(1))
    {
      this._connectionString = connectionString;
    }

    protected override DatabaseConnection Create()
    {
      return new DatabaseConnection(_connectionString);
    }

    public override void Expire(DatabaseConnection connection)
    {
      connection.Dispose();
    }

    public override bool Validate(DatabaseConnection connection)
    {
      return connection.IsOpen;
    }
  }

  public class Client
  {
    public static void TestCase1()
    {
      // Create the ConnectionPool:
      DatabaseConnectionPool pool = new DatabaseConnectionPool(
        "Data Source=DENNIS;Initial Catalog=TESTDB;Integrated Security=True;");

      // Get a connection:
      DatabaseConnection connection = pool.CheckOut();

      // Use the connection

      // Return the connection:
      pool.CheckIn(connection);
    }
  }
}

實現方式（二）：使用對象構造方法和預分配方式實現 ObjectPool 類。

namespace ObjectPoolPattern.Implementation2
{
  /// <summary>
  /// 對象池
  /// </summary>
  /// <typeparam name="T">對象類型</typeparam>
  public class ObjectPool<T> where T : class
  {
    private readonly Func<T> _objectFactory;
    private readonly ConcurrentQueue<T> _queue = new ConcurrentQueue<T>();

    /// <summary>
    /// 對象池
    /// </summary>
    /// <param name="objectFactory">構造緩存對象的函數</param>
    public ObjectPool(Func<T> objectFactory)
    {
      _objectFactory = objectFactory;
    }

    /// <summary>
    /// 構造指定數量的對象
    /// </summary>
    /// <param name="count">數量</param>
    public void Allocate(int count)
    {
      for (int i = 0; i < count; i++)
        _queue.Enqueue(_objectFactory());
    }

    /// <summary>
    /// 緩存一個對象
    /// </summary>
    /// <param name="obj">對象</param>
    public void Enqueue(T obj)
    {
      _queue.Enqueue(obj);
    }

    /// <summary>
    /// 獲取一個對象
    /// </summary>
    /// <returns>對象</returns>
    public T Dequeue()
    {
      T obj;
      return !_queue.TryDequeue(out obj) ? _objectFactory() : obj;
    }
  }

  class Program
  {
    static void Main(string[] args)
    {
      var pool = new ObjectPool<byte[]>(() => new byte[65535]);
      pool.Allocate(1000);

      var buffer = pool.Dequeue();

      // .. do something here ..

      pool.Enqueue(buffer);
    }
  }
}

《設計模式之美》為 Dennis Gao 發布於博客園的系列文章，任何未經作者本人同意的人為或爬蟲轉載均為耍流氓。