詳解從ObjectPool到CAS指令

// 用於存放池化對象的包裝數組 長度為構造函數傳入的max - 1
// 為什麼 -1 是因為性能考慮把第一個元素放到 _firstItem中
private protected readonly ObjectWrapper[] _items;

// 池化策略 創建對象 和 回收對象的防范
private protected readonly IPooledObjectPolicy<T> _policy;

// 是否默認的策略 是一個IL優化 使編譯器生成call 而不是 callvirt
private protected readonly bool _isDefaultPolicy;

// 因為池化大多數場景隻會獲取一個對象 為瞭性能考慮 單獨整一個對象不放在數組中 
// 避免數組遍歷
private protected T? _firstItem;

// 這個類是在2.1中引入的，以盡可能地避免接口調用 也就是去虛擬化 callvirt
private protected readonly PooledObjectPolicy<T>? _fastPolicy;

/// <summary>
/// Creates an instance of <see cref="DefaultObjectPool{T}"/>.
/// </summary>
/// <param name="policy">The pooling policy to use.</param>
public DefaultObjectPool(IPooledObjectPolicy<T> policy)
    : this(policy, Environment.ProcessorCount * 2)
{
    // 從這個構造方法可以看出，如果我們不指定ObjectPool的池大小
    // 那麼池大小會是當前可用的CPU核心數*2
}

/// <summary>
/// Creates an instance of <see cref="DefaultObjectPool{T}"/>.
/// </summary>
/// <param name="policy">The pooling policy to use.</param>
/// <param name="maximumRetained">The maximum number of objects to retain in the pool.</param>
public DefaultObjectPool(IPooledObjectPolicy<T> policy, int maximumRetained)
{
    _policy = policy ?? throw new ArgumentNullException(nameof(policy));

    // 是否為可以消除callvirt的策略
    _fastPolicy = policy as PooleObjectPolicy<T>;
    // 如上面備註所說 是否為默認策略 可以消除callvirt
    _isDefaultPolicy = IsDefaultPolicy();

    // 初始化_items數組 容量還剩一個在 _firstItem中
    _items = new ObjectWrapper[maximumRetained - 1];

    bool IsDefaultPolicy()
    {
        var type = policy.GetType();

        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(DefaultPooledObjectPolicy<>);
    }
}

public override T Get()
{
    // 先看_firstItem是否有值
    // 這裡使用瞭 Interlocked.CompareExchange這個方法
    // 原子性的判斷 _firstItem是否等於item
    // 如果等於那把null賦值給_firstItem
    // 然後返回_firstItem對象原始的值  反之就是什麼也不做
    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;
            // 通過原子性的Interlocked.CompareExchange嘗試讀取一個元素
            // 讀取成功則返回
            if (item != null && Interlocked.CompareExchange(ref items[i].Element, null, item) == item)
            {
                return item;
            }
        }

        // 如果遍歷整個沒有獲取到元素
        // 那麼走創建方法，創建一個
        item = Create();
    }

    return item;
}

public override void Return(T obj)
{
    // 使用策略的Return方法對元素進行處理
    // 比如 List<T> 需要調用Claer方法清除集合內元素
    // StringBuilder之類的也需要調用Claer方法清除緩存的字符
    if (_isDefaultPolicy || (_fastPolicy?.Return(obj) ?? _policy.Return(obj)))
    {
        // 先嘗試將歸還的元素賦值到 _firstItem中
        if (_firstItem != null || Interlocked.CompareExchange(ref _firstItem, obj, null) != null)
        {
            var items = _items;
            // 如果 _firstItem已經存在元素
            // 那麼遍歷整個數組空間 找一個存儲為null的空位將對象存儲起來
            for (var i = 0; i < items.Length && Interlocked.CompareExchange(ref items[i].Element, obj, null) != null; ++i)
            {
            }
        }
    }
}

// localtion1 需要比較的引用A
// value 計劃給引用A 賦的值
// comparand 和引用A比較的引用
public static T CompareExchange<T> (ref T location1, T value, T comparand) 
where T : class;

var a = 1;
// a == 1的話就將其置為0
// 判斷是否成功就看返回的值是否為a的原始值
if(Interlocked.CompareExchange(ref a, 0, 1) == 1)
	Console.WriteLine("1.成功");
	
// 現在a已經變為0 這個交換不會成功
if(Interlocked.CompareExchange(ref a, 0, 1) == 1)
	Console.WriteLine("2.成功");