前言
上一篇文章主要介绍了ObjectPool的理论知识，再来介绍一下Microsoft.Extensions.ObjectPool是如何实现的.
核心组件
ObjectPool
ObjectPool是一个泛型抽象接口，他抽象了两个方法Get和Return
- Get方法用于从对象池获取到可用对象，如果对象不可用则创建对象并返回出来
- Return方法用户将对象返回到对象池
///
/// A pool of objects.
///
/// The type of objects to pool.
public abstract class ObjectPool where T : class
{
///
/// Gets an object from the pool if one is available, otherwise creates one.
///
/// A
public abstract T Get();
///
/// Return an object to the pool.
///
/// The object to add to the pool.
public abstract void Return(T obj);
}
ObjectPoolProvider
ObjectPoolProvider是一个抽象接口他内置了Create的泛型方法和Create的泛型抽象方法，他是一个基于默认策略的。
///
/// A provider of
public abstract class ObjectPoolProvider
{
///
/// Creates an
/// The type to create a pool for.
public ObjectPool Create() where T : class, new()
{
return Create(new DefaultPooledObjectPolicy());
}
///
/// Creates an
/// The type to create a pool for.
public abstract ObjectPool Create(IPooledObjectPolicy policy) where T : class;
}
IPooledObjectPolicy
IPooledObjectPolicy是一个泛型接口，提供策略管理对象池，该类也定义了两个方法Create和Return以提供策略实现
- Create用于创建相关的类实例
- Return用于将已经使用完的对象放回到池中，包括重置对象状态以及是否能够放回到池中
///
/// Represents a policy for managing pooled objects.
///
/// The type of object which is being pooled.
public interface IPooledObjectPolicy
{
///
/// Create a
/// The
T Create();
///
/// 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.
///
/// The object to return to the pool.
/// true if the object should be returned to the pool. false if it's not possible/desirable for the pool to keep the object. PooledObjectPolicy是一个泛型抽象类，并且实现了IPooledObjectPolicy，对外提供了两个抽象方法
public abstract class PooledObjectPolicy : IPooledObjectPolicy
{
public abstract T Create();
public abstract bool Return(T obj);
}
实现机制
DefaultObjectPool
DefaultObjectPool实现了ObjectPool，Interlocked.CompareExchange(ref _firstItem, null, item)将_firstItem的值和item的值比较，相等则用null替换_firstItem，否则不操作,不管替换还是不替换返回的都是原来保存在_firstItem的值。
Interlocked可以为多个线程共享的变量提供原子操作。
- Interlocked.Increment：以原子操作的形式递增指定变量的值并存储结果。
- Interlocked.Decrement以原子操作的形式递减指定变量的值并存储结果。
- Interlocked.Add以原子操作的形式，添加两个整数并用两者的和替换第一个整数
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)
{
}
}
}
}
DefaultObjectPoolProvider
DefaultObjectPoolProvider重写了ObjectPoolProvider中Crearte方法，
设置了默认的对象最大数量只能用的是默认的Environment.ProcessorCount * 2(CPU处理器的两倍)
///
/// The default
public class DefaultObjectPoolProvider : ObjectPoolProvider
{
///
/// The maximum number of objects to retain in the pool.
///
public int MaximumRetained { get; set; } = Environment.ProcessorCount * 2;
/// Create(IPooledObjectPolicy policy)
{
if (policy == null)
{
throw new ArgumentNullException(nameof(policy));
}
if (typeof(IDisposable).IsAssignableFrom(typeof(T)))
{
return new DisposableObjectPool(policy, MaximumRetained);
}
return new DefaultObjectPool(policy, MaximumRetained);
}
}
DisposableObjectPool
DisposableObjectPool继承了DefaultObjectPool以及实现了IDisposable用于手动的回收对象
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();
}
}
LeakTrackingObjectPool
LeakTrackingObjectPool实现了ObjectPool，它定义了ConditionalWeakTable他是一个弱引用字典，ConditionalWeakTable
public class LeakTrackingObjectPool : ObjectPool where T : class
{
private readonly ConditionalWeakTable _trackers = new ConditionalWeakTable();
private readonly ObjectPool _inner;
public LeakTrackingObjectPool(ObjectPool inner)
{
if (inner == null)
{
throw new ArgumentNullException(nameof(inner));
}
_inner = inner;
}
public override T Get()
{
var value = _inner.Get();
_trackers.Add(value, new Tracker());
return value;
}
public override void Return(T obj)
{
Tracker tracker;
if (_trackers.TryGetValue(obj, out tracker))
{
_trackers.Remove(obj);
tracker.Dispose();
}
_inner.Return(obj);
}
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}");
}
}
}
}
参考
https://blog.walterlv.com/post/conditional-weak-table.html
https://www.cnblogs.com/edison0621/p/11747912.html