Object Pooling(對象池)實現

在文章開始以前首先要思考的問題是爲何要創建對象池。這和.NET垃圾回收機制有關，正以下面引用所說，內存不是無限的，垃圾回收器最終要回收對象，釋放內存。儘管.NET爲垃圾回收已經進行了大量優化，例如將託管堆劃分爲 3 Generations（代）並設定新建的對象回收的最快，新建的短生命週期對象將進入 Gen 0（新建對象大於或等於 85,000 字節將被看做大對象，直接進入 Gen 2），而 Gen 0 一般狀況下分配比較小的內存，所以Gen 0 將回收的很是快。而高頻率進行垃圾回收致使 CPU 使用率太高，當 Gen 2 包含大量對象時，回收垃圾也將產生性能問題。

.NET 的垃圾回收器管理應用程序的內存分配和釋放。 每當有對象新建時，公共語言運行時都會從託管堆爲對象分配內存。 只要託管堆中有地址空間，運行時就會繼續爲新對象分配空間。 不過，內存並非無限的。 垃圾回收器最終必須執行垃圾回收來釋放一些內存。 垃圾回收器的優化引擎會根據所執行的分配來肯定執行回收的最佳時機。 執行回收時，垃圾回收器會在託管堆中檢查應用程序再也不使用的對象，而後執行必要的操做來回收其內存。參考

構造對象池

.Net Core 在（Base Class Library）基礎類型中添加了 ArrayPool，但 ArrayPool 只適用於數組。針對自定義對象，參考MSDN有一個實現，但沒有初始化池大小，且從池裏取對象的方式比較粗糙，完整的對象池應該包含：

• 池大小
• 初始化委託
• 實例存取方式（FIFO、LIFO 等自定義方式，根據我的需求實現獲取實例方式）
• 獲取實例策略

1. 定義對象存取接口，以實現多種存取策略，例如 FIFO、LIFO

/// <summary>
/// 對象存取方式
/// </summary>
public interface IAccessMode<T>
{
    /// <summary>
    /// 租用對象
    /// </summary>
    /// <returns></returns>
    /// <exception cref="InvalidOperationException"></exception>
    T Rent();
    
    /// <summary>
    /// 返回實例
    /// </summary>
    /// <param name="item"></param>
    void Return(T item);
}

2. 實現存取策略

FIFO

FIFO經過Queue實現，參考

public sealed class FIFOAccessMode<T> : Queue<T>, IAccessMode<T>
{
    private readonly int _capacity;
    private readonly Func<T> _func;
    private int _count;

    public FIFOAccessMode(int capacity, Func<T> func) : base(capacity)
    {
        _capacity = capacity;
        _func = func;
        InitialQueue();
    }

    public T Rent()
    {
        Interlocked.Increment(ref _count);
        return _capacity < _count ? _func.Invoke() : Dequeue();
    }

    public void Return(T item)
    {
        if (_count > _capacity)
        {
            var disposable = (IDisposable)item;
            disposable.Dispose();
        }
        else
        {
            Enqueue(item);
        }
        Interlocked.Decrement(ref _count);
    }

    private void InitialQueue()
    {
        for (var i = 0; i < _capacity; i++)
        {
            Enqueue(_func.Invoke());
        }
    }
}

LIFO

在LIFO中藉助Stack特性實現進棧出棧，所以該策略繼承自Stack，參考

public sealed class LIFOAccessModel<T> : Stack<T>, IAccessMode<T>
{
    private readonly int _capacity;
    private readonly Func<T> _func;
    private int _count;

    public LIFOAccessModel(int capacity, Func<T> func) : base(capacity)
    {
        _capacity = capacity;
        _func = func;
        InitialStack();
    }

    public T Rent()
    {
        Interlocked.Increment(ref _count);
        return _capacity < _count ? _func.Invoke() : Pop();
    }

    public void Return(T item)
    {
        if (_count > _capacity)
        {
            var disposable = (IDisposable)item;
            disposable.Dispose();
        }
        else
        {
            Push(item);
        }
        Interlocked.Decrement(ref _count);
    }

    private void InitialStack()
    {
        for (var i = 0; i < _capacity; i++)
        {
            Push(_func.Invoke());
        }
    }
}

注意：以上兩個實現都遵循池容量不變原則，但租用的實例能夠超過對象池大小，返還時還將檢測該實例直接釋放仍是進入池中。而如何控制池大小和併發將在下面說明。

3.Pool實現

public class Pool<T> : IDisposable where T : IDisposable
{
    private int _capacity;
    private IAccessMode<T> _accessMode;
    private readonly object _locker = new object();
    private readonly Semaphore _semaphore;

    public Pool(AccessModel accessModel, int capacity, Func<T> func)
    {
        _capacity = capacity;
        _semaphore = new Semaphore(capacity, capacity);
        InitialAccessMode(accessModel, capacity, func);
    }

    private void InitialAccessMode(AccessModel accessModel, int capacity, Func<T> func)
    {
        switch (accessModel)
        {
            case AccessModel.FIFO:
                _accessMode = new FIFOAccessMode<T>(capacity, func);
                break;
            case AccessModel.LIFO:
                _accessMode = new LIFOAccessModel<T>(capacity, func);
                break;
            default:
                throw new NotImplementedException();
        }
    }

    public T Rent()
    {
        _semaphore.WaitOne();
        return _accessMode.Rent();
    }

    public void Return(T item)
    {
        _accessMode.Return(item);
        _semaphore.Release();
    }

    public void Dispose()
    {
        if (!typeof(IDisposable).IsAssignableFrom(typeof(T))) return;

        lock (_locker)
        {
            while (_capacity > 0)
            {
                var disposable = (IDisposable)_accessMode.Rent();
                _capacity--;
                disposable.Dispose();
            }

            _semaphore.Dispose();
        }
    }
}

在Pool中如何控制程序池併發，這裏咱們引入了 Semaphore 以控制併發，這裏將嚴格控制程序池大小，避免內存溢出。

4.使用

Student 類用做測試

public class Student : IDisposable
{
    public string Name { get; set; }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    private bool _disposed;

    protected virtual void Dispose(bool disposing)
    {
        if (_disposed)
            return;

        if (disposing)
        {
            Name = null;
             //Free any other managed objects here.
        }

        _disposed = true;
    }
}

public void TestPool()
{
    Func<Student> func = NewStudent;
    var pool = new Pool<Student>(AccessModel.FIFO, 2, func);
    for (var i = 0; i < 3; i++)
    {
        Student temp = pool.Rent();
        //todo:Some operations
        pool.Return(temp);
    }

    Student temp1 = pool.Rent();

    pool.Return(temp1);

    pool.Dispose();
}

public Student NewStudent()
{
    return new Student();
}

總結：至此，一個完整的對象池創建完畢。

安裝與使用：現已發佈到NuGet服務器，可在程序包管理控制檯中輸入安裝命令使用。

Install-Package CustomObjectPool