设计模式之美：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 发布于博客园的系列文章，任何未经作者本人同意的人为或爬虫转载均为耍流氓。