.NET Core 3.0之深入源碼理解ObjectPool（二）

寫在前面

前文主要介紹了ObjectPool的一些理論基礎，本文主要從源碼角度理解Microsoft.Extensions.ObjectPool是如何實現的。下圖為其三大核心組件圖：

核心組件

ObjectPool

ObjectPool是一個泛型抽象類，里面只有兩個抽象方法，Get和Return。它從底層定義了最一般的接口。

• Get方法用於從對象池獲取到可用對象，如果對象不可用則創建對象並返回出來
• Return方法用戶將對象返回到對象池

源碼如下：

public abstract class ObjectPool<T> where T : class
{
    /// <summary>
    /// Gets an object from the pool if one is available, otherwise creates one.
    /// </summary>
    /// <returns>A <typeparamref name="T"/>.</returns>
    public abstract T Get();

    /// <summary>
    /// Return an object to the pool.
    /// </summary>
    /// <param name="obj">The object to add to the pool.</param>
    public abstract void Return(T obj);
}

ObjectPoolProvider

ObjectPoolProvider也是抽象類，其內部內置了一個已經實現的Create泛型方法以及一個抽象Create方法，這代表兩種ObjectPool的創建方式，一個是基於默認策略的，一個是基於用戶自定義策略的。

public abstract class ObjectPoolProvider
{
    /// <summary>
    /// Creates an <see cref="ObjectPool"/>.
    /// </summary>
    /// <typeparam name="T">The type to create a pool for.</typeparam>
    public ObjectPool<T> Create<T>() where T : class, new()
    {
        return Create<T>(new DefaultPooledObjectPolicy<T>());
    }

    /// <summary>
    /// Creates an <see cref="ObjectPool"/> with the given <see cref="IPooledObjectPolicy{T}"/>.
    /// </summary>
    /// <typeparam name="T">The type to create a pool for.</typeparam>
    public abstract ObjectPool<T> Create<T>(IPooledObjectPolicy<T> policy) where T : class;
}

IPooledObjectPolicy

這個接口是一個泛型接口，用於提供一種策略來管理對象池中的對象，同樣也有兩個方法，Create和Return。

• Create方法用於創建相關類型實例
• Return方法用於將已經使用好的對象放回到對象池的時候進行邏輯處理，包括對象的狀態重置以及是否能夠放回到對象池

public interface IPooledObjectPolicy<T>
{
    /// <summary>
    /// Create a <typeparamref name="T"/>.
    /// </summary>
    /// <returns>The <typeparamref name="T"/> which was created.</returns>
    T Create();

    /// <summary>
    /// Runs some processing when an object was returned to the pool. Can be used to reset the state of an object and indicate if the object should be returned to the pool.
    /// </summary>
    /// <param name="obj">The object to return to the pool.</param>

    /// <returns><code>true</code> if the object should be returned to the pool. <code>false</code> if it's not possible/desirable for the pool to keep the object.</returns>
    bool Return(T obj);
}

該接口有一個實現PooledObjectPolicy，這是一個抽象類，內部有兩個抽象方法：

public abstract class PooledObjectPolicy<T> : IPooledObjectPolicy<T>
{
    public abstract T Create();

    public abstract bool Return(T obj);
}

實現機制

其內部實現邏輯較為簡單，充分考慮到了一般實現、對象追蹤、對象釋放等場景的使用方式。

以下為其邏輯圖：

DefaultObjectPool

DefaultObjectPool實現了ObjectPool，其內部維護了一個結構體類型的私有數組，用於存儲相關對象。該數組的大小在構造函數中定義，其實際大小為輸入值減去1（默認情況下，其值為邏輯處理器數量的兩倍）主要是因為DefaultObjectPool單獨將首項定義了出來。

以下為DefaultObjectPool中Get和Return的實現：

public override T Get()
{
    var item = _firstItem;
    if (item == null || Interlocked.CompareExchange(ref _firstItem, null, item) != item)
    {
        var items = _items;
        for (var i = 0; i < items.Length; i++)
        {
            item = items[i].Element;
            if (item != null && Interlocked.CompareExchange(ref items[i].Element, null, item) == item)
            {
                return item;
            }
        }

        item = Create();
    }

    return item;
}

public override void Return(T obj)
{
    if (_isDefaultPolicy || (_fastPolicy?.Return(obj) ?? _policy.Return(obj)))
    {
        if (_firstItem != null || Interlocked.CompareExchange(ref _firstItem, obj, null) != null)
        {
            var items = _items;
            for (var i = 0; i < items.Length && Interlocked.CompareExchange(ref items[i].Element, obj, null) != null; ++i)
            {
            }
        }
    }
}

通過源碼可以知道這兩個方法大量使用了Interlocked.CompareExchange：

public static int CompareExchange(
    ref int location1,
    int value,
    int comparand
)

比較location1與comparand，如果不相等，什么都不做；如果location1與comparand相等，則用value替換location1的值。無論比較結果相等與否，返回值都是location1中原有的值。

Interlocked.CompareExchange的使用確保了線程安全性。

DefaultObjectPoolProvider

DefaultObjectPoolProvider實現了ObjectPoolProvider，該類重寫了Create方法並返回ObjectPool對象。該類還定義了MaximumRetained屬性，默認情況下，其值為邏輯處理器數量的兩倍。

其源碼如下，比較簡單：

public class DefaultObjectPoolProvider : ObjectPoolProvider
{
    /// <summary>
    /// The maximum number of objects to retain in the pool.
    /// </summary>
    public int MaximumRetained { get; set; } = Environment.ProcessorCount * 2;

    /// <inheritdoc/>
    public override ObjectPool<T> Create<T>(IPooledObjectPolicy<T> policy)
    {
        if (policy == null)
        {
            throw new ArgumentNullException(nameof(policy));
        }

        if (typeof(IDisposable).IsAssignableFrom(typeof(T)))
        {
            return new DisposableObjectPool<T>(policy, MaximumRetained);
        }

        return new DefaultObjectPool<T>(policy, MaximumRetained);
    }
}

其中DisposableObjectPool是DefaultObjectPool類的派生類，這個類也實現了IDisposable，用於創建可手動釋放的ObjectPool對象。

其相關代碼如下：

public void Dispose()
{
    _isDisposed = true;

    DisposeItem(_firstItem);
    _firstItem = null;

    ObjectWrapper[] items = _items;
    for (var i = 0; i < items.Length; i++)
    {
        DisposeItem(items[i].Element);
        items[i].Element = null;
    }
}

private void DisposeItem(T item)
{
    if (item is IDisposable disposable)
    {
        disposable.Dispose();
    }
}

DefaultPooledObjectPolicy

該類繼承了PooledObjectPolicy，實現也非常簡單。

不過值得注意的是，PooledObjectPolicy還有一個實現StringBuilderPooledObjectPolicy，這個類從命名上看就知道是基於StringBuilder的。其內部默認定義了StringBuilder的大小以及初始化容量。並確定了超出容量后，將不允許歸還對象。

在我們自定義PooledObjectPolicy的時候，可以參考這段實現去擴展新的PooledObjectPolicy對象。

我們看一下源碼：

public class StringBuilderPooledObjectPolicy : PooledObjectPolicy<StringBuilder>
{
    public int InitialCapacity { get; set; } = 100;

    public int MaximumRetainedCapacity { get; set; } = 4 * 1024;

    public override StringBuilder Create()
    {
        return new StringBuilder(InitialCapacity);
    }

    public override bool Return(StringBuilder obj)
    {
        if (obj.Capacity > MaximumRetainedCapacity)
        {
            // Too big. Discard this one.
            return false;
        }

        obj.Clear();
        return true;
    }
}

對象追蹤

該庫內部定義了LeakTrackingObjectPool和LeakTrackingObjectPoolProvider用於追蹤對象狀態。

• LeakTrackingObjectPoolProvider會根據構造函數傳入的ObjectPoolProvider類型對象，創建LeakTrackingObjectPool實例。
• LeakTrackingObjectPool內部定義了ConditionalWeakTable<T, Tracker>類型的數組，MSDN的解釋是使編譯器可以將對象字段動態附加到托管對象，這個對象會自動維護內部的鍵值對，而不會一直使其停留在內存中。

Tracker是LeakTrackingObjectPool的內部類，其目的是為了方便我們對對象本身進行維護跟蹤，其定義如下：

private class Tracker : IDisposable
{
    private readonly string _stack;
    private bool _disposed;

    public Tracker()
    {
        _stack = Environment.StackTrace;
    }

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

    ~Tracker()
    {
        if (!_disposed && !Environment.HasShutdownStarted)
        {
            Debug.Fail($"{typeof(T).Name} was leaked. Created at: {Environment.NewLine}{_stack}");
        }
    }
}