详解从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.成功");