1. What is an object pool
Object pooling is simply a software design idea that provides reusable capabilities for objects. We often say that there is borrowing and repaying, and it is not difficult to borrow again. The object pool ensures that the object can be reused through the two actions of borrowing and repaying, thereby saving the performance overhead of frequently creating objects. The most commonly used scene for object pools is game design, because there are a large number of reusable objects in the game, and the continuous emergence of bullets is not regenerated. There is something called a connection pool in the database. Whenever the database cannot connect, experienced developers will often check whether the connection pool is full first. This is actually the specific implementation of the object pool pattern in a specific field. Therefore, an object pool is essentially a container responsible for creating and destroying a set of objects. The biggest advantage of an object pool is that it can manage each object in the pool independently, deciding whether they need to be recycled or reused. We all know that creating a new object requires a certain amount of system resources. Once these objects can be used repeatedly, it can save system resource overhead, which will be very helpful in improving system performance. The following code implements a simple object pool implemented by Microsoft's official documentation:
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);
}
}
2. Object pool in .NET Core
exist.NET CoreChina Microsoft has provided us with an implementation of object pool, i.e.. It mainly provides three core components, namelyObjectPool、ObjectPoolProviderandIPooledObjectPolicy。ObjectPoolIt is an abstract class that provides two methods: Get and Return, which is called borrowing and returning.ObjectPoolProviderIt is also an abstract class, and its responsibility is to create ObjectPool. It provides two Create methods. The difference between the two is that the parameterless version is essentially usingDefaultPooledObjectPolicy. It andDefaultObjectPool, DefaultObjectPoolProvider are all default implementations provided by Microsoft. IPooledObjectPolicy can define different policies for different object pools to determine how to borrow and whether the object can be returned. DefaultObjectPool uses ObjectWrapper[] to manage objects internally. The size of ObjectWrapper[] is equal to maximumRetained-1. By default, maximumRetained is equal to * 2, mainly used here()method,
The specific code is as follows:
public override T Get()
{
var item = _firstItem;
if (item == null || (ref _firstItem, null, item) != item)
{
var items = _items;
for (var i = 0; i < ; i++)
{
item = items[i].Element;
if (item != null && (ref items[i].Element, null, item) == item)
{
return item;
}
}
item = Create();
}
return item;
}
// Non-inline to improve its code quality as uncommon path
[MethodImpl()]
private T Create() => _fastPolicy?.Create() ?? _policy.Create();
public override void Return(T obj)
{
if (_isDefaultPolicy || (_fastPolicy?.Return(obj) ?? _policy.Return(obj)))
{
if (_firstItem != null || (ref _firstItem, obj, null) != null)
{
var items = _items;
for (var i = 0; i < && (ref items[i].Element, obj, null) != null; ++i)
{
}
}
}
}
Used here()Method, Get() method willitems[i].ElementandnullConducts exchange, sets the specified element to null and returns the original value. The Return() method willitems[i].ElementThe value after exchanging with obj is not null, which means that the specified element has been returned. This method will only exchange when the first parameter and the third parameter are equal.
Having said so much, let’s take a look at the specific usage of object pools:
var service = new ServiceCollection();
//Use DefaultObjectPoolProvider
<ObjectPoolProvider, DefaultObjectPoolProvider>();
//Use the default policy
<ObjectPool<Foo>>(serviceProvider =>
{
var objectPoolProvider = <ObjectPoolProvider>();
return <Foo>();
});
//Use custom policy
<ObjectPool<Foo>>(serviceProvider =>
{
var objectPoolProvider = <ObjectPoolProvider>();
return (new FooObjectPoolPolicy());
});
var serviceProvider = _service.BuildServiceProvider();
var objectPool = _serviceProvider.GetService<ObjectPool<Foo>>();
//Borrow and return, twice is the same object
var item1 = ();
(item1);
var item2 = ();
(item1, item2);//true
//There are loans and no returns, the two times are different objects
var item3 = ();
var item4 = ();
(item3, item4);//false
In the above code, Foo and FooObjectPoolPolicy are two tool classes:
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 = ().ToString("N"),
CreatedAt = ,
CreatedBy = "zs"
};
}
public bool Return(Foo obj)
{
return true;
}
}
TIP：When you need to control how objects in the object pool are created, you can consider implementing customIPooledObjectPolicy<T>,on the contraryDefaultPooledObjectPolicy<T>The implementation can fully meet your use.
3. Summary of this article
Implementing object pool can be consideredConcurrentBag、Stack、Queueas well asBlockingCollectionMicrosoft has implemented a simple object pool for us in .NET Core. In most cases, we only need to define our ownIPooledObjectPolicyDecide how the partner should borrow and repay. In short, in the game worldGameObject, the connection pool in the database are all specific implementations of the object pool pattern in their respective fields.
TIP：Object pool is a software design model that reduces resource overhead and improves system performance by multiplexing objects. Its core is to control the life cycle of objects in the container to avoid active recycling of the system. Objects borrowed from the object pool must be returned in time, otherwise there will be no available resources in the object pool.
This is the end of this article about the use of Object Pool in .NET Core. For more related Object Pool in .NET Core, please search for my previous articles or continue browsing the related articles below. I hope you will support me more in the future!