.NET Core對象池的應(yīng)用:擴(kuò)展篇

更新時間：2021年09月01日 17:09:28 作者：Artech

本文主要講解.NET Core對象池的池化集合、池化StringBuilder、ArrayPool<T>以及MemoryPool<T>，需要了解的小伙伴可以多學(xué)習(xí)這篇文章，相信可以幫助到你

原則上所有的引用類型對象都可以通過對象池來提供，但是在具體的應(yīng)用中需要權(quán)衡是否值得用。雖然對象池能夠通過對象復(fù)用的方式避免GC，但是它存儲的對象會耗用內(nèi)存，如果對象復(fù)用的頻率很小，使用對象池是不值的。如果某個小對象的使用周期很短，能夠確保GC在第0代就能將其回收，這樣的對象其實(shí)也不太適合放在對象池中，因?yàn)榈?代GC的性能其實(shí)是很高的。除此之外，對象釋放到對象池之后就有可能被其他線程提取出來，如果釋放的時機(jī)不對，有可能造成多個線程同時操作同一個對象?？傊覀冊谑褂弥暗每紤]當(dāng)前場景是否適用對象池，在使用的時候嚴(yán)格按照“有借有還”、“不用才還”的原則。

一、池化集合

我們知道一個List<T>對象內(nèi)部會使用一個數(shù)組來保存列表元素。數(shù)組是定長的，所以List<T>有一個最大容量（體現(xiàn)為它的Capacity屬性）。當(dāng)列表元素數(shù)量超過數(shù)組容量時，必須對列表對象進(jìn)行擴(kuò)容，即創(chuàng)建一個新的數(shù)組并將現(xiàn)有的元素拷貝進(jìn)去。當(dāng)前元素越多，需要執(zhí)行的拷貝操作就越多，對性能的影響自然就越大。如果我們創(chuàng)建List<T>對象，并在其中不斷地添加對象，有可能會導(dǎo)致多次擴(kuò)容，所以如果能夠預(yù)知元素數(shù)量，我們在創(chuàng)建List<T>對象時應(yīng)該指定一個合適的容量。但是很多情況下，列表元素數(shù)量是動態(tài)變化的，我們可以利用對象池來解決這個問題。

接下來我們通過一個簡單的實(shí)例來演示一下如何采用對象池的方式來提供一個List<Foobar>對象，元素類型Foobar如下所示。為了能夠顯式控制列表對象的創(chuàng)建和歸還，我們自定義了如下這個表示池化對象策略的FoobarListPolicy。通過《設(shè)計篇》針對對象池默認(rèn)實(shí)現(xiàn)的介紹，我們知道直接繼承PooledObjectPolicy<T>類型比實(shí)現(xiàn)IPooledObjectPolicy<T>接口具有更好的性能優(yōu)勢。

public class FoobarListPolicy : PooledObjectPolicy<List<Foobar>>
{
    private readonly int _initCapacity;
    private readonly int _maxCapacity;

    public FoobarListPolicy(int initCapacity, int maxCapacity)
    {
        _initCapacity = initCapacity;
        _maxCapacity = maxCapacity;
    }
    public override List<Foobar> Create() => new List<Foobar>(_initCapacity);
    public override bool Return(List<Foobar> obj)
   {
        if(obj.Capacity <= _maxCapacity)
        {
            obj.Clear();
            return true;
        }        
        return false;
    }
}

public class Foobar
{
    public int Foo { get; }
    public int Bar { get; }
    public Foobar(int foo, int bar)
    {
        Foo = foo;
        Bar = bar;
    }
}

如代碼片段所示，我們在FoobarListPolicy類型中定義了兩個字段，_initCapacity字段表示列表創(chuàng)建時指定的初始容量，另一個_maxCapacity則表示對象池存儲列表的最大容量。之所以要限制列表的最大容量，是為了避免復(fù)用幾率很少的大容量列表常駐內(nèi)存。在實(shí)現(xiàn)的Create方法中，我們利用初始容量創(chuàng)建出List<Foobar>對象。在Return方法中，我們先將待回歸的列表清空，然后根據(jù)其當(dāng)前容量決定是否要將其釋放到對象池。下面的程序演示了采用對象池的方式來提供List<Foobar>列表。如代碼片段所示，我們在調(diào)用ObjectPoolProvider對象的Create<T>創(chuàng)建代表對象池的ObjectPool<T>對象時，指定了作為池化對象策略的FoobarListPolicy對象。我們將初始和最大容量設(shè)置成1K（1024）和1M（1024*1024）。我們利用對象池提供了一個List<Foobar>對象，并在其中添加了10000個元素。如果這段代碼執(zhí)行的頻率很高，對整體的性能是有提升的。

class Program
{
    static void Main()
    {
        var objectPool = new ServiceCollection()
            .AddSingleton<ObjectPoolProvider, DefaultObjectPoolProvider>()
            .BuildServiceProvider()
            .GetRequiredService<ObjectPoolProvider>()
            .Create(new FoobarListPolicy(1024, 1024*1024));

        string json;
        var list = objectPool.Get();
        try
        {
            list.AddRange(Enumerable.Range(1, 1000).Select(it => new Foobar(it, it)));
            json = JsonConvert.SerializeObject(list);
        }
        finally
        {
            objectPool.Return(list);
        }
    }
}

二、池化StringBuilder

我們知道，如果頻繁涉及針對字符串拼接的操作，應(yīng)該使用StringBuilder以獲得更好的性能。實(shí)際上，StringBuilder對象自身也存在類似于列表對象的擴(kuò)容問題，所以最好的方式就是利用對象池的方式來復(fù)用它們。對象池框架針對StringBuilder對象的池化提供的原生支持，我們接下來通過一個簡單的示例來演示具體的用法。

class Program
{
    static void Main()
    {
        var objectPool = new ServiceCollection()
            .AddSingleton<ObjectPoolProvider, DefaultObjectPoolProvider>()
            .BuildServiceProvider()
            .GetRequiredService<ObjectPoolProvider>()
            .CreateStringBuilderPool(1024, 1024*1024);

        var builder = objectPool.Get();
        try
        {
            for (int index = 0; index < 100; index++)
            {
                builder.Append(index);
            }
            Console.WriteLine(builder);
        }
        finally
        {
            objectPool.Return(builder);
        }
    }
}

如上面的代碼片段所示，我們直接可以調(diào)用ObjectPoolProvider的CreateStringBuilderPool擴(kuò)展方法就可以得到針對StringBuilder的對象池對象（類型為ObjectPool<StringBuilder>）。我們上面演示實(shí)例一樣，我們指定的也是StringBuilder對象的初始和最大容量。池化StringBuilder對象的核心體現(xiàn)在對應(yīng)的策略類型上，即如下這個StringBuilderPooledObjectPolicy類型。

public class StringBuilderPooledObjectPolicy : PooledObjectPolicy<StringBuilder>
{
    public int InitialCapacity { get; set; } = 100;
    public int MaximumRetainedCapacity { get; set; } = 4 * 1024;

    public override StringBuilder Create()=> new StringBuilder(InitialCapacity);
    public override bool Return(StringBuilder obj)
    {
        if (obj.Capacity > MaximumRetainedCapacity)
        {
            return false;
        }
        obj.Clear();
        return true;
    }
}

可以看出它的定義和我們前面定義的FoobarListPolicy類型如出一轍。在默認(rèn)情況下，池化StringBuilder對象的初始化和最大容量分別為100和5096。如下所示的是ObjectPoolProvider用于創(chuàng)建ObjectPool<StringBuilder>對象的兩個CreateStringBuilderPool擴(kuò)展方法的定義。

public static class ObjectPoolProviderExtensions
{
    public static ObjectPool<StringBuilder> CreateStringBuilderPool( this ObjectPoolProvider provider)
        => provider.Create(new StringBuilderPooledObjectPolicy());       

    public static ObjectPool<StringBuilder> CreateStringBuilderPool( this ObjectPoolProvider provider, int initialCapacity, int maximumRetainedCapacity)
    {
        var policy = new StringBuilderPooledObjectPolicy()
        {
            InitialCapacity = initialCapacity,
            MaximumRetainedCapacity = maximumRetainedCapacity,
        };
        return provider.Create(policy);
    }
}

三、ArrayPool<T>

接下來介紹的和前面的內(nèi)容沒有什么關(guān)系，但同屬于我們常用對象池使用場景。我們在編程的時候會大量使用到集合，集合類型（像基于鏈表的集合除外）很多都采用一個數(shù)組作為內(nèi)部存儲，所以會有前面所說的擴(kuò)容問題。如果這個數(shù)組很大，還會造成GC的壓力。我們在前面已經(jīng)采用池化集合的方案解決了這個問題，其實(shí)這個問題還有另外一種解決方案。

在很多情況下，當(dāng)我們需要創(chuàng)建一個對象的時候，實(shí)際上需要的一段確定長度的連續(xù)對象序列。假設(shè)我們將數(shù)組對象進(jìn)行池化，當(dāng)我們需要一段定長的對象序列的時候，從池中提取一個長度大于所需長度的可用數(shù)組，并從中截取可用的連續(xù)片段（一般從頭開始）就可以了。在使用完之后，我們無需執(zhí)行任何的釋放操作，直接將數(shù)組對象歸還到對象池中就可以了。這種基于數(shù)組的對象池使用方式可以利用ArrayPool<T>來實(shí)現(xiàn)。

public abstract class ArrayPool<T>
{    
    public abstract T[] Rent(int minimumLength);
    public abstract void Return(T[] array, bool clearArray);

    public static ArrayPool<T> Create();
    public static ArrayPool<T> Create(int maxArrayLength, int maxArraysPerBucket);

    public static ArrayPool<T> Shared { get; }
}

如上面的代碼片段所示，抽象類型ArrayPool<T>同樣提供了完成對象池兩個基本操作的方法，其中Rent方法從對象池中“借出”一個不小于（不是等于）指定長度的數(shù)組，該數(shù)組最終通過Return方法釋放到對象池。Return方法的clearArray參數(shù)表示在歸還數(shù)組之前是否要將其清空，這取決我們針對數(shù)組的使用方式。如果我們每次都需要覆蓋原始的內(nèi)容，就沒有必要額外執(zhí)行這種多余操作。

我們可以通過靜態(tài)方法Create創(chuàng)建一個ArrayPool<T>對象。池化的數(shù)組并未直接存儲在對象池中，長度接近的多個數(shù)組會被封裝成一個桶（Bucket）中，這樣的好處是在執(zhí)行Rent方法的時候可以根據(jù)指定的長度快速找到最為匹配的數(shù)組（大于并接近指定的長度）。對象池存儲的是一組Bucket對象，允許的數(shù)組長度越大，桶的數(shù)量越多。Create方法除了可以指定數(shù)組允許最大長度，還可以指定每個桶的容量。除了調(diào)用靜態(tài)Create方法創(chuàng)建一個獨(dú)占使用的ArrayPool<T>對象之外，我們可以使用靜態(tài)屬性Shared返回一個應(yīng)用范圍內(nèi)共享的ArrayPool<T>對象。ArrayPool<T>的使用非常方便，如下的代碼片段演示了一個讀取文件的實(shí)例。

class Program
{
    static async Task Main()
    {
        using var fs = new FileStream("test.txt", FileMode.Open);
        var length = (int)fs.Length;
        var bytes = ArrayPool<byte>.Shared.Rent(length);
        try
        {
            await fs.ReadAsync(bytes, 0, length);
            Console.WriteLine(Encoding.Default.GetString(bytes, 0, length));
        }
        finally
        {
            ArrayPool<byte>.Shared.Return(bytes);
        }
    }
}

四、MemoryPool<T>

數(shù)組是對托管堆中用于存儲同類對象的一段連續(xù)內(nèi)存的表達(dá)，而另一個類型Memory<T>則具有更加廣泛的應(yīng)用，因?yàn)樗粌H僅可以表示一段連續(xù)的托管（Managed）內(nèi)存，還可以表示一段連續(xù)的Native內(nèi)存，甚至線程堆棧內(nèi)存。具有如下定義的MemoryPool<T>表示針對Memory<T>類型的對象池。

public abstract class MemoryPool<T> : IDisposable
{    
    public abstract int MaxBufferSize { get; }
    public static MemoryPool<T> Shared { get; }

    public void Dispose();
    protected abstract void Dispose(bool disposing);
    public abstract IMemoryOwner<T> Rent(int minBufferSize = -1);
}

public interface IMemoryOwner<T> : IDisposable
{
    Memory<T> Memory { get; }
}

MemoryPool<T>和ArrayPool<T>具有類似的定義，比如通過靜態(tài)屬性Shared獲取當(dāng)前應(yīng)用全局共享的MemoryPool<T>對象，通過Rent方法從對象池中借出一個不小于指定大小的Memory<T>對象。不同的是，MemoryPool<T>的Rent方法并沒有直接返回一個Memory<T>對象，而是一個封裝了該對象的IMemoryOwner<T>對象。MemoryPool<T>也沒有定義一個用來釋放Memory<T>對象的Reurn方法，這個操作是通過IMemoryOwner<T>對象的Dispose方法完成的。如果采用MemoryPool<T>，前面針對ArrayPool<T>的演示實(shí)例可以改寫成如下的形式。

class Program
{
    static async Task Main()
    {
        using var fs = new FileStream("test.txt", FileMode.Open);
        var length = (int)fs.Length;
        using (var memoryOwner = MemoryPool<byte>.Shared.Rent(length))
        {
            await fs.ReadAsync(memoryOwner.Memory);
            Console.WriteLine(Encoding.Default.GetString( memoryOwner.Memory.Span.Slice(0,length)));
        }                
    }
}

.NET Core對象池的應(yīng)用:編程篇

.NET Core對象池的應(yīng)用:設(shè)計篇

到此這篇關(guān)于.NET Core對象池的應(yīng)用:擴(kuò)展篇的文章就介紹到這了,更多相關(guān).NET Core對象池的應(yīng)用內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: