对于聊聊GenericObjectPool的泄露检测感兴趣的读者，本文将提供您所需要的所有信息，并且为您提供关于.NETCore3.0之深入源码理解ObjectPool（一）、.NETCore3.0之
对于聊聊GenericObjectPool的泄露检测感兴趣的读者，本文将提供您所需要的所有信息，并且为您提供关于.NET Core 3.0之深入源码理解ObjectPool（一）、.NET Core 3.0之深入源码理解ObjectPool（二）、.NET Core 中对象池 Object Pool的使用、.NET Core中Object Pool的多种用法详解的宝贵知识。
本文目录一览：- 聊聊GenericObjectPool的泄露检测
- .NET Core 3.0之深入源码理解ObjectPool（一）
- .NET Core 3.0之深入源码理解ObjectPool（二）
- .NET Core 中对象池 Object Pool的使用
- .NET Core中Object Pool的多种用法详解
聊聊GenericObjectPool的泄露检测
序
本文主要聊聊GenericObjectPool的abandon参数。主要用来做连接池的泄露检测用。
object的状态
commons-pool2-2.4.2-sources.jar!/org/apache/commons/pool2/PooledObjectState.java
public enum PooledObjectState {
/**
* In the queue, not in use.
*/
IDLE,
/**
* In use.
*/
ALLOCATED,
/**
* In the queue, currently being tested for possible eviction.
*/
EVICTION,
/**
* Not in the queue, currently being tested for possible eviction. An
* attempt to borrow the object was made while being tested which removed it
* from the queue. It should be returned to the head of the queue once
* eviction testing completes.
* TODO: Consider allocating object and ignoring the result of the eviction
* test.
*/
EVICTION_RETURN_TO_HEAD,
/**
* In the queue, currently being validated.
*/
VALIDATION,
/**
* Not in queue, currently being validated. The object was borrowed while
* being validated and since testOnBorrow was configured, it was removed
* from the queue and pre-allocated. It should be allocated once validation
* completes.
*/
VALIDATION_PREALLOCATED,
/**
* Not in queue, currently being validated. An attempt to borrow the object
* was made while previously being tested for eviction which removed it from
* the queue. It should be returned to the head of the queue once validation
* completes.
*/
VALIDATION_RETURN_TO_HEAD,
/**
* Failed maintenance (e.g. eviction test or validation) and will be / has
* been destroyed
*/
INVALID,
/**
* Deemed abandoned, to be invalidated.
*/
ABANDONED,
/**
* Returning to the pool.
*/
RETURNING
}
abandon一般是用于连接泄露的检测，检测的是在使用的对象，比如怀疑那个对象被占用时间超长，那估计是程序异常或bug导致对象borrow了但忘记归还，或者对象borrow之后使用时间太长。
AbandonedConfig
除了commons-pool2-2.4.2-sources.jar!/org/apache/commons/pool2/impl/GenericObjectPoolConfig.java，还有这个AbandonedConfig commons-pool2-2.4.2-sources.jar!/org/apache/commons/pool2/impl/AbandonedConfig.java
public class AbandonedConfig {
/**
* Whether or not borrowObject performs abandoned object removal.
*/
private boolean removeAbandonedOnBorrow = false;
/**
* <p>Flag to remove abandoned objects if they exceed the
* removeAbandonedTimeout when borrowObject is invoked.</p>
*
* <p>The default value is false.</p>
*
* <p>If set to true, abandoned objects are removed by borrowObject if
* there are fewer than 2 idle objects available in the pool and
* <code>getNumActive() > getMaxTotal() - 3</code></p>
*
* @return true if abandoned objects are to be removed by borrowObject
*/
public boolean getRemoveAbandonedOnBorrow() {
return this.removeAbandonedOnBorrow;
}
/**
* <p>Flag to remove abandoned objects if they exceed the
* removeAbandonedTimeout when borrowObject is invoked.</p>
*
* @param removeAbandonedOnBorrow true means abandoned objects will be
* removed by borrowObject
* @see #getRemoveAbandonedOnBorrow()
*/
public void setRemoveAbandonedOnBorrow(boolean removeAbandonedOnBorrow) {
this.removeAbandonedOnBorrow = removeAbandonedOnBorrow;
}
/**
* Whether or not pool maintenance (evictor) performs abandoned object
* removal.
*/
private boolean removeAbandonedOnMaintenance = false;
/**
* Timeout in seconds before an abandoned object can be removed.
*/
private int removeAbandonedTimeout = 300;
/**
* Determines whether or not to log stack traces for application code
* which abandoned an object.
*/
private boolean logAbandoned = false;
/**
* PrintWriter to use to log information on abandoned objects.
* Use of default system encoding is deliberate.
*/
private PrintWriter logWriter = new PrintWriter(System.out);
/**
* If the pool implements {@link UsageTracking}, should the pool record a
* stack trace every time a method is called on a pooled object and retain
* the most recent stack trace to aid debugging of abandoned objects?
*/
private boolean useUsageTracking = false;
}
参数
- removeAbandonedOnBorrow 在borrow的时候，是否执行abandon判断，默认false
- removeAbandonedOnMaintenance 是否在evictor中执行abandon判断，默认false
- removeAbandonedTimeout 一个对象在被borrow之后多少秒未归还则认为是abandon，默认为300
- logAbandoned 是否打印abandon的日志，默认为false
- useUsageTracking 是否追踪对象调用并保留最近的调用记录方便debug
removeAbandonedOnBorrow
在borrow方法里头
public T borrowObject(long borrowMaxWaitMillis) throws Exception {
assertOpen();
AbandonedConfig ac = this.abandonedConfig;
if (ac != null && ac.getRemoveAbandonedOnBorrow() &&
(getNumIdle() < 2) &&
(getNumActive() > getMaxTotal() - 3) ) {
removeAbandoned(ac);
}
PooledObject<T> p = null;
// Get local copy of current config so it is consistent for entire
// method execution
boolean blockWhenExhausted = getBlockWhenExhausted();
boolean create;
long waitTime = System.currentTimeMillis();
//......
updateStatsBorrow(p, System.currentTimeMillis() - waitTime);
return p.getObject();
}
removeAbandonedOnMaintenance
在evictor线程里头
public void evict() throws Exception {
assertOpen();
if (idleObjects.size() > 0) {
PooledObject<T> underTest = null;
EvictionPolicy<T> evictionPolicy = getEvictionPolicy();
synchronized (evictionLock) {
EvictionConfig evictionConfig = new EvictionConfig(
getMinEvictableIdleTimeMillis(),
getSoftMinEvictableIdleTimeMillis(),
getMinIdle());
boolean testWhileIdle = getTestWhileIdle();
for (int i = 0, m = getNumTests(); i < m; i++) {
if (evictionIterator == null || !evictionIterator.hasNext()) {
evictionIterator = new EvictionIterator(idleObjects);
}
if (!evictionIterator.hasNext()) {
// Pool exhausted, nothing to do here
return;
}
try {
underTest = evictionIterator.next();
} catch (NoSuchElementException nsee) {
// Object was borrowed in another thread
// Don''t count this as an eviction test so reduce i;
i--;
evictionIterator = null;
continue;
}
if (!underTest.startEvictionTest()) {
// Object was borrowed in another thread
// Don''t count this as an eviction test so reduce i;
i--;
continue;
}
// User provided eviction policy could throw all sorts of
// crazy exceptions. Protect against such an exception
// killing the eviction thread.
boolean evict;
try {
evict = evictionPolicy.evict(evictionConfig, underTest,
idleObjects.size());
} catch (Throwable t) {
// Slightly convoluted as SwallowedExceptionListener
// uses Exception rather than Throwable
PoolUtils.checkRethrow(t);
swallowException(new Exception(t));
// Don''t evict on error conditions
evict = false;
}
if (evict) {
destroy(underTest);
destroyedByEvictorCount.incrementAndGet();
} else {
if (testWhileIdle) {
boolean active = false;
try {
factory.activateObject(underTest);
active = true;
} catch (Exception e) {
destroy(underTest);
destroyedByEvictorCount.incrementAndGet();
}
if (active) {
if (!factory.validateObject(underTest)) {
destroy(underTest);
destroyedByEvictorCount.incrementAndGet();
} else {
try {
factory.passivateObject(underTest);
} catch (Exception e) {
destroy(underTest);
destroyedByEvictorCount.incrementAndGet();
}
}
}
}
if (!underTest.endEvictionTest(idleObjects)) {
// TODO - May need to add code here once additional
// states are used
}
}
}
}
}
AbandonedConfig ac = this.abandonedConfig;
if (ac != null && ac.getRemoveAbandonedOnMaintenance()) {
removeAbandoned(ac);
}
}
removeAbandonedTimeout
在removeAbandoned方法里头
/**
* Recover abandoned objects which have been checked out but
* not used since longer than the removeAbandonedTimeout.
*
* @param ac The configuration to use to identify abandoned objects
*/
private void removeAbandoned(AbandonedConfig ac) {
// Generate a list of abandoned objects to remove
final long now = System.currentTimeMillis();
final long timeout =
now - (ac.getRemoveAbandonedTimeout() * 1000L);
ArrayList<PooledObject<T>> remove = new ArrayList<PooledObject<T>>();
Iterator<PooledObject<T>> it = allObjects.values().iterator();
while (it.hasNext()) {
PooledObject<T> pooledObject = it.next();
synchronized (pooledObject) {
if (pooledObject.getState() == PooledObjectState.ALLOCATED &&
pooledObject.getLastUsedTime() <= timeout) {
pooledObject.markAbandoned();
remove.add(pooledObject);
}
}
}
// Now remove the abandoned objects
Iterator<PooledObject<T>> itr = remove.iterator();
while (itr.hasNext()) {
PooledObject<T> pooledObject = itr.next();
if (ac.getLogAbandoned()) {
pooledObject.printStackTrace(ac.getLogWriter());
}
try {
invalidateObject(pooledObject.getObject());
} catch (Exception e) {
e.printStackTrace();
}
}
}
标记为abandon之后，立马放入remove队列中，然后遍历进行invalidateObject
public void invalidateObject(T obj) throws Exception {
PooledObject<T> p = allObjects.get(new IdentityWrapper<T>(obj));
if (p == null) {
if (isAbandonedConfig()) {
return;
} else {
throw new IllegalStateException(
"Invalidated object not currently part of this pool");
}
}
synchronized (p) {
if (p.getState() != PooledObjectState.INVALID) {
destroy(p);
}
}
ensureIdle(1, false);
}
logAbandoned
最后是作用在这个类 commons-pool2-2.4.2-sources.jar!/org/apache/commons/pool2/impl/DefaultPooledObject.java
public synchronized boolean allocate() {
if (state == PooledObjectState.IDLE) {
state = PooledObjectState.ALLOCATED;
lastBorrowTime = System.currentTimeMillis();
lastUseTime = lastBorrowTime;
borrowedCount++;
if (logAbandoned) {
borrowedBy = new AbandonedObjectCreatedException();
}
return true;
} else if (state == PooledObjectState.EVICTION) {
// TODO Allocate anyway and ignore eviction test
state = PooledObjectState.EVICTION_RETURN_TO_HEAD;
return false;
}
// TODO if validating and testOnBorrow == true then pre-allocate for
// performance
return false;
}
useUsageTracking
public void use(T pooledObject) {
AbandonedConfig ac = this.abandonedConfig;
if (ac != null && ac.getUseUsageTracking()) {
PooledObject<T> wrapper = allObjects.get(new IdentityWrapper<T>(pooledObject));
wrapper.use();
}
}
就是会调用一下PooledObject的use进行统计 commons-pool2-2.4.2-sources.jar!/org/apache/commons/pool2/proxy/BaseProxyHandler.java
/**
* Invoke the given method on the wrapped object.
*
* @param method The method to invoke
* @param args The arguments to the method
* @return The result of the method call
* @throws Throwable If the method invocation fails
*/
Object doInvoke(Method method, Object[] args) throws Throwable {
validateProxiedObject();
T object = getPooledObject();
if (usageTracking != null) {
usageTracking.use(object);
}
return method.invoke(object, args);
}
doc
- commons-pool2 2 - poolObject API与状态机
- 对象池common-pool2源码分析之对象状态
- GenericObjectPool 避免泄漏
- apache commons pool之GenericObjectPool分析（通用对象池技术）
.NET Core 3.0之深入源码理解ObjectPool（一）
写在前面
对象池是一种比较常用的提高系统性能的软件设计模式，它维护了一系列相关对象列表的容器对象，这些对象可以随时重复使用，对象池节省了频繁创建对象的开销。
它使用取用/归还-重复取用的操作模式，如下图所示：
本文将主要介绍对象池的基本概念、对象池的优势及其工作机制，下一篇文档将从源码角度介绍.NET Core 3.0是如何实现对象池的。
对象池基础
对象池的基本概念
对象池的核心概念是容器，其表示形式可以认为是列表。每当有新的对象创建请求进入时，都会通过从池中分配一个对象来满足该请求。当我们需要获取某个对象时，可以从池中获取。既然有了对象池，那么也就很方便我们就很容易建立起对象的管理与追踪了了。
对象池的优势
我们知道一旦应用程序启动并运行，内存使用就会受到系统所需对象的数量和大小的影响。
我们知道创建一个对象的实例，是需要消耗一定的系统资源，尤其是该对象的构造十分复杂的时候，再加上需要频繁创建的时候，其实例化所消耗的资源更加昂贵。如果我们能有一种办法减少这种昂贵的系统开销，这对系统性能的提升是十分有帮助的。
对象池理念的出现，有助于我们解决复杂对象的重复创建所引发的资源开销问题。对象存储在某种类型的列表或者说数组中，我们可以和获取数组中的子项一样获取已经存在在对象池中的对象。
对象池的最大优点是，它可以自主管理内部已经创建的对象，包括回收和重复使用对象。程序在使用完某个对象后，会将其发还至对象池，而不是在内存中销毁他们。
对象池通过资源的分配，因而也就减少了应用程序所需的垃圾回收数量。这对于需要频繁创建同一对象的功能来说，对象池最大程度地减少了系统资源的消耗。
简单来说，对象池的设计目标就是要使对象可以得到重复使用，而不是被垃圾回收器回收。
对象池的工作机制
当客户端程序需要某个对象时，对象池首先尝试提供一个已经创建的对象。如果没有可用的对象，则会创建一个新对象。这类似于一个GetOrAdd的操作。同时对象池中对象的数量就会减少，直到该对象已经使用完，那么它就会被放回到对象池池中以等待使用。这就是为什么对象池有助于重用性、并减少了在获取对象时创建对象所涉及的开销的原因。
另外，需要注意的是，只要池中至少有一个对象，该池就会一直保留在内存中。只要对象池还在，里面的对象也会一直存在。
当对象池用于并发操作时，需要确保对象池是线程安全的，而且其本身还要有很高的性能。
ConcurrentBag对象池解决方案
这个解决方案来自于MSDN，ConcurrentBag <T>用于存储对象，因为它支持快速插入和删除，尤其是在同一线程同时添加和删除项目时。该示例可以进一步扩展为围绕IProducerConsumerCollection <T>构建，该数据由bag数据结构实现，ConcurrentQueue <T>和ConcurrentStack <T>也是如此。
1: using System; 2: using System.Collections.Concurrent; 3: using System.Threading; 4: using System.Threading.Tasks; 5: 6: 7: namespace ObjectPoolExample 8: { 9: public class ObjectPool<T> 10: { 11: private ConcurrentBag<T> _objects; 12: private Func<T> _objectGenerator; 13: 14: public ObjectPool(Func<T> objectGenerator) 15: { 16: if (objectGenerator == null) throw new ArgumentNullException("objectGenerator"); 17: _objects = new ConcurrentBag<T>(); 18: _objectGenerator = objectGenerator; 19: } 20: 21: public T GetObject() 22: { 23: T item; 24: if (_objects.TryTake(out item)) return item; 25: return _objectGenerator(); 26: } 27: 28: public void PutObject(T item) 29: { 30: _objects.Add(item); 31: } 32: } 33: 34: class Program 35: { 36: static void Main(string[] args) 37: { 38: CancellationTokenSource cts = new CancellationTokenSource(); 39: 40: // Create an opportunity for the user to cancel. 41: Task.Run(() => 42: { 43: if (Console.ReadKey().KeyChar == ''c'' || Console.ReadKey().KeyChar == ''C'') 44: cts.Cancel(); 45: }); 46: 47: ObjectPool<MyClass> pool = new ObjectPool<MyClass> (() => new MyClass()); 48: 49: // Create a high demand for MyClass objects. 50: Parallel.For(0, 1000000, (i, loopState) => 51: { 52: MyClass mc = pool.GetObject(); 53: Console.CursorLeft = 0; 54: // This is the bottleneck in our application. All threads in this loop 55: // must serialize their access to the static Console class. 56: Console.WriteLine("{0:####.####}", mc.GetValue(i)); 57: 58: pool.PutObject(mc); 59: if (cts.Token.IsCancellationRequested) 60: loopState.Stop(); 61: 62: }); 63: Console.WriteLine("Press the Enter key to exit."); 64: Console.ReadLine(); 65: cts.Dispose(); 66: } 67: 68: } 69: 70: // A toy class that requires some resources to create. 71: // You can experiment here to measure the performance of the 72: // object pool vs. ordinary instantiation. 73: class MyClass 74: { 75: public int[] Nums {get; set;} 76: public double GetValue(long i) 77: { 78: return Math.Sqrt(Nums[i]); 79: } 80: public MyClass() 81: { 82: Nums = new int[1000000]; 83: Random rand = new Random(); 84: for (int i = 0; i < Nums.Length; i++) 85: Nums[i] = rand.Next(); 86: } 87: } 88: }
参考链接：https://docs.microsoft.com/en-us/dotnet/standard/collections/thread-safe/how-to-create-an-object-pool
.NET Core 3.0之深入源码理解ObjectPool（二）
写在前面
前文主要介绍了ObjectPool的一些理论基础，本文主要从源码角度理解Microsoft.Extensions.ObjectPool是如何实现的。下图为其三大核心组件图：
核心组件
ObjectPool
ObjectPool是一个泛型抽象类，里面只有两个抽象方法，Get和Return。它从底层定义了最一般的接口。
- Get方法用于从对象池获取到可用对象，如果对象不可用则创建对象并返回出来
- Return方法用户将对象返回到对象池
源码如下：
1: public abstract class ObjectPool<T> where T : class 2: { 3: /// <summary> 4: /// Gets an object from the pool if one is available, otherwise creates one. 5: /// </summary> 6: /// <returns>A <typeparamref name="T"/>.</returns> 7: public abstract T Get(); 8: 9: /// <summary> 10: /// Return an object to the pool. 11: /// </summary> 12: /// <param name="obj">The object to add to the pool.</param> 13: public abstract void Return(T obj); 14: }ObjectPoolProvider
ObjectPoolProvider也是抽象类，其内部内置了一个已经实现的Create泛型方法以及一个抽象Create方法，这代表两种ObjectPool的创建方式，一个是基于默认策略的，一个是基于用户自定义策略的。
1: public abstract class ObjectPoolProvider 2: { 3: /// <summary> 4: /// Creates an <see cref="ObjectPool"/>. 5: /// </summary> 6: /// <typeparam name="T">The type to create a pool for.</typeparam> 7: public ObjectPool<T> Create<T>() where T : class, new() 8: { 9: return Create<T>(new DefaultPooledObjectPolicy<T>()); 10: } 11: 12: /// <summary> 13: /// Creates an <see cref="ObjectPool"/> with the given <see cref="IPooledObjectPolicy{T}"/>. 14: /// </summary> 15: /// <typeparam name="T">The type to create a pool for.</typeparam> 16: public abstract ObjectPool<T> Create<T>(IPooledObjectPolicy<T> policy) where T : class; 17: }IPooledObjectPolicy
这个接口是一个泛型接口，用于提供一种策略来管理对象池中的对象，同样也有两个方法，Create和Return。
- Create方法用于创建相关类型实例
- Return方法用于将已经使用好的对象放回到对象池的时候进行逻辑处理，包括对象的状态重置以及是否能够放回到对象池
1: public interface IPooledObjectPolicy<T> 2: { 3: /// <summary> 4: /// Create a <typeparamref name="T"/>. 5: /// </summary> 6: /// <returns>The <typeparamref name="T"/> which was created.</returns> 7: T Create(); 8: 9: /// <summary> 10: /// 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. 11: /// </summary> 12: /// <param name="obj">The object to return to the pool.</param> 13: /// <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> 14: bool Return(T obj); 15: }该接口有一个实现PooledObjectPolicy，这是一个抽象类，内部有两个抽象方法：
1: public abstract class PooledObjectPolicy<T> : IPooledObjectPolicy<T> 2: { 3: public abstract T Create(); 4: 5: public abstract bool Return(T obj); 6: }实现机制
其内部实现逻辑较为简单，充分考虑到了一般实现、对象追踪、对象释放等场景的使用方式。
以下为其逻辑图：
DefaultObjectPool
DefaultObjectPool实现了ObjectPool，其内部维护了一个结构体类型的私有数组，用于存储相关对象。该数组的大小在构造函数中定义，其实际大小为输入值减去1（默认情况下，其值为逻辑处理器数量的两倍）主要是因为DefaultObjectPool单独将首项定义了出来。
以下为DefaultObjectPool中Get和Return的实现：
1: public override T Get() 2: { 3: var item = _firstItem; 4: if (item == null || Interlocked.CompareExchange(ref _firstItem, null, item) != item) 5: { 6: var items = _items; 7: for (var i = 0; i < items.Length; i++) 8: { 9: item = items[i].Element; 10: if (item != null && Interlocked.CompareExchange(ref items[i].Element, null, item) == item) 11: { 12: return item; 13: } 14: } 15: 16: item = Create(); 17: } 18: 19: return item; 20: } 21: 22: public override void Return(T obj) 23: { 24: if (_isDefaultPolicy || (_fastPolicy?.Return(obj) ?? _policy.Return(obj))) 25: { 26: if (_firstItem != null || Interlocked.CompareExchange(ref _firstItem, obj, null) != null) 27: { 28: var items = _items; 29: for (var i = 0; i < items.Length && Interlocked.CompareExchange(ref items[i].Element, obj, null) != null; ++i) 30: { 31: } 32: } 33: } 34: }通过源码可以知道这两个方法大量使用了Interlocked.CompareExchange：
1: public static int CompareExchange(2: ref int location1,3: int value,4: int comparand5: )
比较location1与comparand，如果不相等，什么都不做；如果location1与comparand相等，则用value替换location1的值。无论比较结果相等与否，返回值都是location1中原有的值。
Interlocked.CompareExchange的使用确保了线程安全性。
DefaultObjectPoolProvider
DefaultObjectPoolProvider实现了ObjectPoolProvider，该类重写了Create方法并返回ObjectPool对象。该类还定义了MaximumRetained属性，默认情况下，其值为逻辑处理器数量的两倍。
其源码如下，比较简单：
1: public class DefaultObjectPoolProvider : ObjectPoolProvider 2: { 3: /// <summary> 4: /// The maximum number of objects to retain in the pool. 5: /// </summary> 6: public int MaximumRetained { get; set; } = Environment.ProcessorCount * 2; 7: 8: /// <inheritdoc/> 9: public override ObjectPool<T> Create<T>(IPooledObjectPolicy<T> policy) 10: { 11: if (policy == null) 12: { 13: throw new ArgumentNullException(nameof(policy)); 14: } 15: 16: if (typeof(IDisposable).IsAssignableFrom(typeof(T))) 17: { 18: return new DisposableObjectPool<T>(policy, MaximumRetained); 19: } 20: 21: return new DefaultObjectPool<T>(policy, MaximumRetained); 22: } 23: }其中DisposableObjectPool是DefaultObjectPool类的派生类，这个类也实现了IDisposable，用于创建可手动释放的ObjectPool对象。
其相关代码如下：
1: public void Dispose() 2: { 3: _isDisposed = true; 4: 5: DisposeItem(_firstItem); 6: _firstItem = null; 7: 8: ObjectWrapper[] items = _items; 9: for (var i = 0; i < items.Length; i++) 10: { 11: DisposeItem(items[i].Element); 12: items[i].Element = null; 13: } 14: } 15: 16: private void DisposeItem(T item) 17: { 18: if (item is IDisposable disposable) 19: { 20: disposable.Dispose(); 21: } 22: }DefaultPooledObjectPolicy
该类继承了PooledObjectPolicy，实现也非常简单。
不过值得注意的是，PooledObjectPolicy还有一个实现StringBuilderPooledObjectPolicy，这个类从命名上看就知道是基于StringBuilder的。其内部默认定义了StringBuilder的大小以及初始化容量。并确定了超出容量后，将不允许归还对象。
在我们自定义PooledObjectPolicy的时候，可以参考这段实现去扩展新的PooledObjectPolicy对象。
我们看一下源码：
1: public class StringBuilderPooledObjectPolicy : PooledObjectPolicy<StringBuilder> 2: { 3: public int InitialCapacity { get; set; } = 100; 4: 5: public int MaximumRetainedCapacity { get; set; } = 4 * 1024; 6: 7: public override StringBuilder Create() 8: { 9: return new StringBuilder(InitialCapacity); 10: } 11: 12: public override bool Return(StringBuilder obj) 13: { 14: if (obj.Capacity > MaximumRetainedCapacity) 15: { 16: // Too big. Discard this one. 17: return false; 18: } 19: 20: obj.Clear(); 21: return true; 22: } 23: }对象追踪
该库内部定义了LeakTrackingObjectPool和LeakTrackingObjectPoolProvider用于追踪对象状态。
- LeakTrackingObjectPoolProvider会根据构造函数传入的ObjectPoolProvider类型对象，创建LeakTrackingObjectPool实例。
- LeakTrackingObjectPool内部定义了ConditionalWeakTable<T, Tracker>类型的数组，MSDN的解释是使编译器可以将对象字段动态附加到托管对象，这个对象会自动维护内部的键值对，而不会一直使其停留在内存中。
Tracker是LeakTrackingObjectPool的内部类，其目的是为了方便我们对对象本身进行维护跟踪，其定义如下：
1: private class Tracker : IDisposable 2: { 3: private readonly string _stack; 4: private bool _disposed; 5: 6: public Tracker() 7: { 8: _stack = Environment.StackTrace; 9: } 10: 11: public void Dispose() 12: { 13: _disposed = true; 14: GC.SuppressFinalize(this); 15: } 16: 17: ~Tracker() 18: { 19: if (!_disposed && !Environment.HasShutdownStarted) 20: { 21: Debug.Fail($"{typeof(T).Name} was leaked. Created at: {Environment.NewLine}{_stack}"); 22: } 23: } 24: }原文出处：https://www.cnblogs.com/edison0621/p/11747912.html
.NET Core 中对象池 Object Pool的使用
一、什么是对象池
对象池简单来说就是一种为对象提供可复用能力的软件设计思路。我们常说有借有还，再借不难，而对象池就是通过借和还这样两个动作来保证对象可以被重复使用，从而节省频繁创建对象的性能开销。对象池最常用的场景是游戏设计，因为在游戏中大量存在着可复用的对象，源源不断的子弹出现并不是循环再生的。在数据库中存在着被称为连接池的东西，每当出现数据库无法连接的情况时，经验丰富的开发人员往往会先检查连接池是否满了，这其实就是对象池模式在特定领域的具体实现。因此对象池本质上就是负责一组对象创建和销毁的容器。 对象池最大的优势是可以自主地管理池子内的每个对象，决定它们是需要被回收还是可以重复使用。我们都知道创建一个新对象需要消耗一定的系统资源，一旦这些对象可以重复地使用就可以节省系统资源开销，这对提高系统性能会非常有帮助。下面的代码实微软官方文档实现的一个简单的对象池：
public class ObjectPool<T> : IObjectPool<T>
{
private Func<T> _instanceFactory;
private ConcurrentBag<T> _instanceItems;
public ObjectPool(Func<T> instanceFactory)
{
_instanceFactory = instanceFactory ??
throw new ArgumentNullException(nameof(instanceFactory));
_instanceItems = new ConcurrentBag<T>();
}
public T Get()
{
T item;
if (_instanceItems.TryTake(out item)) return item;
return _instanceFactory();
}
public void Return(T item)
{
_instanceItems.Add(item);
}
}
二、.NET Core 中的对象池
在.NET Core 中微软已经为我们提供了对象池的实现，即Microsoft.Extensions.ObjectPool。它主要提供了三个核心的组件，分别是ObjectPool、ObjectPoolProvider和IPooledObjectPolicy。ObjectPool是一个抽象类，对外提供了Get和Return两个方法，这就是所谓的有借有还。ObjectPoolProvider同样是一个抽象类，它的职责就是创建ObjectPool，它提供了两个Create方法，两者的区别是无参数版本本质上使用的是DefaultPooledObjectPolicy。它和DefaultObjectPool、DefaultObjectPoolProvider都是微软提供的默认实现，IPooledObjectPolicy可以为不同的对象池定义不同的策略，来决定对象如何借、是否可以还。DefaultObjectPool内部使用ObjectWrapper[]来管理对象，ObjectWrapper[]的大小等于 maximumRetained-1，默认情况下maximumRetained等于Environment.ProcessorCount * 2，这里主要用到了Interlocked.CompareExchange()方法，
具体代码如下：
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;
}
// Non-inline to improve its code quality as uncommon path
[MethodImpl(MethodImplOptions.NoInlining)]
private T Create() => _fastPolicy?.Create() ?? _policy.Create();
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()方法，Get()方法将items[i].Element和null进行交换，将指定元素设为 null 并返回原始值。Return()方法将items[i].Element和obj交换后的值不为 null，表示指定元素已经归还，这个方法只有在第一个参数和第三个参数相等时才会发生交换。
说了这么多，我们来看一下对象池具体的用法：
var service = new ServiceCollection();
//使用DefaultObjectPoolProvider
service.AddSingleton<ObjectPoolProvider, DefaultObjectPoolProvider>();
//使用默认策略
service.AddSingleton<ObjectPool<Foo>>(serviceProvider =>
{
var objectPoolProvider = serviceProvider.GetRequiredService<ObjectPoolProvider>();
return objectPoolProvider.Create<Foo>();
});
//使用自定义策略
service.AddSingleton<ObjectPool<Foo>>(serviceProvider =>
{
var objectPoolProvider = serviceProvider.GetRequiredService<ObjectPoolProvider>();
return objectPoolProvider.Create(new FooObjectPoolPolicy());
});
var serviceProvider = _service.BuildServiceProvider();
var objectPool = _serviceProvider.GetService<ObjectPool<Foo>>();
//有借有还，两次是同一个对象
var item1 = objectPool.Get();
objectPool.Return(item1);
var item2 = objectPool.Get();
Assert.AreEqual(item1, item2);//true
//有借无还，两次是不同的对象
var item3 = objectPool.Get();
var item4 = objectPool.Get();
Assert.AreEqual(item3, item4);//false
上面的代码中Foo和FooObjectPoolPolicy是两个工具类：
public class Foo
{
public string Id { get; set; }
public DateTime? CreatedAt { get; set; }
public string CreatedBy { get; set; }
}
public class FooObjectPoolPolicy : IPooledObjectPolicy<Foo>
{
public Foo Create()
{
return new Foo()
{
Id = Guid.NewGuid().ToString("N"),
CreatedAt = DateTime.Now,
CreatedBy = "zs"
};
}
public bool Return(Foo obj)
{
return true;
}
}
TIP：当你需要控制对象池内的对象如何被创建的时候，你可以考虑实现自定义的IPooledObjectPolicy<T>，反之DefaultPooledObjectPolicy<T>实现完全可以满足你的使用。
三、本文小结
实现对象池可以考虑ConcurrentBag、Stack、Queue以及BlockingCollection等多种数据结构，而微软在.NET Core 中已经为我们实现了一个简单的对象池，大多数情况下，我们只需要定义自己的IPooledObjectPolicy去决定对象应该怎么样借、怎么样还。总之游戏世界里的 GameObject、数据库里的连接池，都是对象池模式在各自领域中的具体实现。
TIP：对象池是一种通过复用对象来减少资源开销进而实现提高系统性能的软件设计模式，其核心是控制容器内对象的生命周期来规避系统的主动回收，从对象池中借出的对象必须要及时归还，否则会造成对象池中没有可用资源。
到此这篇关于 .NET Core 中对象池 Object Pool的使用的文章就介绍到这了,更多相关 .NET Core 中对象池 内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！
- .NET Core对象池的应用:扩展篇
- .NET Core对象池的应用:设计篇
- .NET Core对象池的应用:编程篇
- .NET Core中如何实现或使用对象池？
- ASP.NET Core中的对象池介绍
.NET Core中Object Pool的多种用法详解
前言
复用，是一个重要的话题，也是我们日常开发中经常遇到的，不可避免的问题。
举个最为简单，大家最为熟悉的例子，数据库连接池，就是复用数据库连接。
那么复用的意义在那里呢？
简单来说就是减少不必要的资源损耗。
除了数据库连接，可能在不同的情景或需求下，还会有很多其他对象需要进行复用，这个时候就会有所谓的 Object Pool(对象池)。
小伙伴们应该也自己实现过类似的功能，或用ConcurrentBag，或用ConcurrentQueue，或用其他方案。
这也里分享一个在微软文档中的实现
How to: Create an Object Pool by Using a ConcurrentBag
当然，在.NET Core中，微软已经帮我们实现了一个简单的Object Pool。
我们只需要添加Microsoft.Extensions.ObjectPool的引用即可使用了。
Microsoft.Extensions.ObjectPool
Microsoft.Extensions.ObjectPool可以说是.NET Core的一个基础类库。
它位于aspnet的Common项目中，类型其他基础模块都有使用相关的功能，也好比Routing项目。
下面就简单看看它的用法。
在开始之前，我们先定义一个可以复用的object
public class Demo
{
public int Id { get; set; }
public string Name { get; set; }
public DateTime CreateTimte { get; set; }
}
用法1
var defalutPolicy = new DefaultPooledObjectPolicy<Demo>();
//最大可保留对象数量 = Environment.ProcessorCount * 2
var defaultPool = new DefaultObjectPool<Demo>(defalutPolicy);
for (int i = 0; i < PoolSize; i++)
{
item1 = defaultPool.Get();
Console.WriteLine($"#{i+1}-{item1.Id}-{item1.Name}-{item1.CreateTimte}");
}
在创建pool之前，我们要先定义一个Policy。这里直接用自带的DefaultPooledObjectPolicy来构造。
对象池会有一个维护的最大数量，线程数。
通过pool对象的Get方法，从对象池中取出一个对象。
上面代码运行结果
#1-0--01/01/0001 00:00:00
#2-0--01/01/0001 00:00:00
#3-0--01/01/0001 00:00:00
#4-0--01/01/0001 00:00:00
#5-0--01/01/0001 00:00:00
#6-0--01/01/0001 00:00:00
#7-0--01/01/0001 00:00:00
#8-0--01/01/0001 00:00:00
这个结果说明，Object Pool 中的对象都是直接new出来的，并没有对一些属性进行贬值操作，这个时候往往没有太多实际意义。
因为DefaultPooledObjectPolicy本来就是直接new了一个对象出来，很多时候，这并不是我们所期望的！
要想符合我们实际的使用，就要自己定义一个Policy！
下面来看看用法2
用法2
先定义一个Policy，实现 IPooledObjectPolicy 这个接口。T很自然就是我们的Demo类了。
public class DemoPooledObjectPolicy : IPooledObjectPolicy<Demo>
{
public Demo Create()
{
return new Demo { Id = 1, Name = "catcher", CreateTimte = DateTime.Now };
}
public bool Return(Demo obj)
{
return true;
}
}
这里要实现Create和Return两个方法。
见名知义，Create方法就是用来创建Demo对象的，Return方法就是将Demo对象扔回Object Pool的(有借有还)。
然后是用DemoPooledObjectPolicy去替换DefaultPooledObjectPolicy。
var demoPolicy = new DemoPooledObjectPolicy();
var defaultPoolWithDemoPolicy = new DefaultObjectPool<Demo>(demoPolicy,1);
//借
item1 = defaultPoolWithDemoPolicy.Get();
//还
defaultPoolWithDemoPolicy.Return(item1);
//借，但是不还
item2 = defaultPoolWithDemoPolicy.Get();
Console.WriteLine($"{item1.Id}-{item1.Name}-{item1.CreateTimte}");
Console.WriteLine($"{item2.Id}-{item2.Name}-{item2.CreateTimte}");
Console.WriteLine(item1 == item2);
//创建一个新的
item3 = defaultPoolWithDemoPolicy.Get();
Console.WriteLine($"{item3.Id}-{item3.Name}-{item3.CreateTimte}");
Console.WriteLine(item3 == item1);
这里定义了对象池只保留一个对象。
由于从object pool中取出来之后，有一步还回去的操作，所以item1和item2应当是同一个对象。
从object pool中拿出了item2之后，它并没有还回去，所以object pool会基于我们定义的Policy去创建一个新的对象出来。
下面是用法2的输出结果：
1-catcher-09/17/2018 22:32:38
1-catcher-09/17/2018 22:32:38
True
1-catcher-09/17/2018 22:32:38
False
可以看到item1,item2和item3的各个属性是一样的，并且item1和item2确实是同一个对象。item3和item1并不是同一个。
用法3
除了DefaultObjectPool外，还有DefaultObjectPoolProvider也可以创建一个Object Pool。
创建一个Object Pool，一定是离不开Policy的，所以这里还是用了我们自己定义的DemoPooledObjectPolicy。
var defaultProvider = new DefaultObjectPoolProvider();
var policy = new DemoPooledObjectPolicy();
//default maximumRetained is Environment.ProcessorCount * 2
ObjectPool<Demo> pool = defaultProvider.Create(policy);
item1 = pool.Get();
pool.Return(item1);
item2 = pool.Get();
Console.WriteLine($"{item1.Id}-{item1.Name}-{item1.CreateTimte}");
Console.WriteLine($"{item2.Id}-{item2.Name}-{item2.CreateTimte}");
Console.WriteLine(item1 == item2);
item3 = pool.Get();
Console.WriteLine($"{item3.Id}-{item3.Name}-{item3.CreateTimte}");
Console.WriteLine(item3 == item2);
用Provider创建Object Pool时，不能指定保留的最大对象数量，只能用的是默认的Environment.ProcessorCount * 2。
后面的使用，和用法2是一样的。
可以看到item1和item2是同一个对象。从Object Pool中取对象的时候，会取第一个，所以还回去后，再取的话，还是会取到原来的第一个。
item3那里是直接从Object Pool中取出来的，没有再次创建，因为这里的Object Pool维护着多个对象，而不是用法2中的只有一个，所以它是直接从Pool中拿的。
下面是输出结果
1-catcher-09/17/2018 22:38:34
1-catcher-09/17/2018 22:38:34
True
1-catcher-09/17/2018 22:38:34
False
和用法2，本质是一样的。
用法4
好像上面的用法，都不那么像我们正常使用的。我们还是需要依赖注入的。
那么我们最后就来看看怎么结合依赖注入吧。当然这里的本质还是离不开Policy和Provider这两个东西。
IServiceCollection services = new ServiceCollection();
services.AddSingleton<ObjectPoolProvider, DefaultObjectPoolProvider>();
services.AddSingleton(s =>
{
var provider = s.GetRequiredService<ObjectPoolProvider>();
return provider.Create(new DemoPooledObjectPolicy());
});
ServiceProvider serviceProvider = services.BuildServiceProvider();
var pool = serviceProvider.GetService<ObjectPool<Demo>>();
item1 = pool.Get();
pool.Return(item1);
item2 = pool.Get();
Console.WriteLine($"{item1.Id}-{item1.Name}-{item1.CreateTimte}");
Console.WriteLine($"{item2.Id}-{item2.Name}-{item2.CreateTimte}");
Console.WriteLine(item1 == item2);
item3 = pool.Get();
Console.WriteLine($"{item3.Id}-{item3.Name}-{item3.CreateTimte}");
Console.WriteLine(item3 == item2);
我们首先需要完成对Provider的注册，然后直接拿它的实例去创建一个Object Pool即可。
如果想在其他地方用，通过构造函数注入即可。
这里的结果也是和前面一样的，没什么好多说的。
总结
在这几种用法中，我们最常用的应该是用法4。
但是无论那种用法，我们都需要了解，Object Pool离不开Pool，Policy和Provider这三个家伙。
有了这三个，或许我们就可以为所欲为了。
当然，它还提供了几个特殊的东西，有兴趣的可以去看看。
•LeakTrackingObjectPool
•StringBuilderPooledObjectPolicy
最后用一个脑图结束本文。
以上所述是小编给大家介绍的.NET Core中Object Pool的多种用法详解，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对网站的支持！
- asp.net core webapi项目配置全局路由的方法示例
- Asp.Net Core中基于Session的身份验证的实现
- .net core 读取本地指定目录下的文件的实例代码
- .NET Core中使用HttpClient的正确姿势
- .Net Core中使用Quartz.Net实践记录
- .Net Core中间件之静态文件(StaticFiles)示例详解
- 详解.NET Core中的数据保护组件
今天关于聊聊GenericObjectPool的泄露检测的分享就到这里，希望大家有所收获，若想了解更多关于.NET Core 3.0之深入源码理解ObjectPool（一）、.NET Core 3.0之深入源码理解ObjectPool（二）、.NET Core 中对象池 Object Pool的使用、.NET Core中Object Pool的多种用法详解等相关知识，可以在本站进行查询。
本文标签：
