public void BoundedObjectPoolInitialisesWithDefaultMaximumSize()
{
Func <TestPoolObject> objGenerator = () => new TestPoolObject();
var pool = new BoundedObjectPool <TestPoolObject>(objGenerator);
Assert.AreEqual(25, pool.MaximumPoolSize);
}
public void BoundedObjectPoolInitialisesWithSpecifiedMaximumSize()
{
Func <TestPoolObject> objGenerator = () => new TestPoolObject();
var pool = new BoundedObjectPool <TestPoolObject>(objGenerator, 5, 10);
Assert.AreEqual(10, pool.MaximumPoolSize);
}
public void BoundedObjectPoolInitialises()
{
Func <TestPoolObject> objGenerator = () => new TestPoolObject();
var pool = new BoundedObjectPool <TestPoolObject>(objGenerator);
Assert.IsNotNull(pool);
}
public void BoundedObjectPoolDoesNotExceedMaxSizeForMultiThreadedCallsWithBlockingOperations()
{
double?[] values = new double?[10000];
Func <TestPoolObject> objGenerator = () => new TestPoolObject();
var pool = new BoundedObjectPool <TestPoolObject>(objGenerator, 5, 10);
var loopResult = Parallel.For(0, 10000, i =>
{
var item = pool.GetObject();
values[i] = item.GetValue(i);
//simulate a blocking operation
if (i % 1000 == 0)
{
Thread.Sleep(100);
}
pool.ReturnObjectToPool(item);
});
while (!loopResult.IsCompleted ||
pool.PoolCount > 10)
{
Thread.Sleep(10);
}
Assert.IsTrue(pool.PoolCount <= 10);
}
public void BoundedObjectPoolGetsObjectFromPool()
{
Func <TestPoolObject> objGenerator = () => new TestPoolObject();
var pool = new BoundedObjectPool <TestPoolObject>(objGenerator, 5, 10);
var item = pool.GetObject();
Assert.IsNotNull(item);
}
static INakedBoundedObjectPool <ExclusiveExecutingLock <ResponseCacheEntry> > CreateExclusiveExecutingLockPool(IServiceProvider serviceProvider)
{
var objectPoolOptions = GetObjectPoolOptions(serviceProvider);
var lifecycleExecutor = serviceProvider.GetRequiredService <ExclusiveExecutingLockLifecycleExecutor <ResponseCacheEntry> >();
var pool = BoundedObjectPool.Create(lifecycleExecutor, objectPoolOptions);
return((INakedBoundedObjectPool <ExclusiveExecutingLock <ResponseCacheEntry> >)pool);
}
public void BoundedObjectPoolResetsObjectStateWhenReturningObjectToPool()
{
Func <TestPoolObject> objGenerator = () => new TestPoolObject();
var pool = new BoundedObjectPool <TestPoolObject>(objGenerator, 5, 10);
var item = pool.GetObject();
pool.ReturnObjectToPool(item);
Assert.IsTrue(item.StateReset);
}
public void BoundedObjectPoolReturnObjectToPoolDoesNotExceedMaxSize()
{
Func <TestPoolObject> objGenerator = () => new TestPoolObject();
var pool = new BoundedObjectPool <TestPoolObject>(objGenerator, 5, 10);
var item = pool.GetObject();
pool.ReturnObjectToPool(item);
Assert.IsTrue(pool.PoolCount <= 10);
}
public void BoundedObjectPoolReturnsMultipleObjectsToPoolDoesNotExceedMaxSize()
{
Func <TestPoolObject> objGenerator = () => new TestPoolObject();
var pool = new BoundedObjectPool <TestPoolObject>(objGenerator, 5, 10);
//simulate a collection of pool items to be returned
TestPoolObject[] items = new TestPoolObject[10];
for (int i = 0; i < items.Length; i++)
{
items[i] = objGenerator();
}
items.ToList().ForEach(i => pool.ReturnObjectToPool(i));
Assert.IsTrue(pool.PoolCount <= 10);
}
public void BoundedObjectPoolGetsObjectFromPoolMultiThreaded()
{
double?[] values = new double?[10000];
Func <TestPoolObject> objGenerator = () => new TestPoolObject();
var pool = new BoundedObjectPool <TestPoolObject>(objGenerator, 5, 10);
Parallel.For(0, 10000, i =>
{
var item = pool.GetObject();
values[i] = item.GetValue(i);
pool.ReturnObjectToPool(item);
});
Assert.IsTrue(values.All(i => i.HasValue));
}
public void BoundedObjectPoolReleasesResourcesForObjectsNotReAddedToPool()
{
Func <TestPoolObject> objGenerator = () => new TestPoolObject();
var pool = new BoundedObjectPool <TestPoolObject>(objGenerator, 5, 10);
//simulate a collection of pool items to be returned
TestPoolObject[] items = new TestPoolObject[10];
for (int i = 0; i < items.Length; i++)
{
items[i] = objGenerator();
}
items.ToList().ForEach(i => pool.ReturnObjectToPool(i));
var itemsDestroyed = items.Where(i => i.ResourcesRelated);
Assert.AreEqual(5, itemsDestroyed.Count());
}
public void BoundedObjectPoolGetsObjectFromPoolMultiThreadedWithBlockingOperations()
{
double?[] values = new double?[10000];
Func <TestPoolObject> objGenerator = () => new TestPoolObject();
var pool = new BoundedObjectPool <TestPoolObject>(objGenerator, 5, 10);
Parallel.For(0, 10000, i =>
{
var item = pool.GetObject();
values[i] = item.GetValue(i);
//simulate a blocking operation
if (i % 1000 == 0)
{
Thread.Sleep(100);
}
pool.ReturnObjectToPool(item);
});
Assert.IsTrue(values.All(i => i.HasValue));
}
/// <summary>
/// 添加<see cref="IExecutingLockPool{TCachePayload}"/>
/// </summary>
/// <param name="services"></param>
private static void AddExecutingLockPool(this IServiceCollection services)
{
services.TryAddSingleton(services =>
{
var options = services.GetRequiredService <IOptions <ResponseCachingExecutingLockOptions> >().Value;
var boundedObjectPoolOptions = new BoundedObjectPoolOptions()
{
MaximumPooled = options.MaximumSemaphorePooled,
MinimumRetained = options.MinimumSemaphoreRetained,
RecycleInterval = options.SemaphoreRecycleInterval,
};
var semaphorePool = BoundedObjectPool.Create(new SinglePassSemaphoreLifecycleExecutor(), boundedObjectPoolOptions);
return((INakedBoundedObjectPool <SemaphoreSlim>)semaphorePool);
});
services.TryAddSingleton(typeof(ExclusiveExecutingLockLifecycleExecutor <>));
services.TryAddSingleton(typeof(SharedExecutingLockLifecycleExecutor <>));
services.TryAddSingleton(serviceProvider => CreateSharedExecutingLockPool(serviceProvider));
services.TryAddSingleton(serviceProvider => CreateExclusiveExecutingLockPool(serviceProvider));
private void InitPool(int maximumPooled, int minimumRetained, int recycleIntervalSeconds = 60)
{
_boundedObjectPool = BoundedObjectPool.Create <BoundedObjectPoolTestClass>(maximumPooled, minimumRetained, recycleIntervalSeconds);
}
