• <button id="eiyoe"><acronym id="eiyoe"></acronym></button>
    <em id="eiyoe"></em>

  • <rp id="eiyoe"><acronym id="eiyoe"><input id="eiyoe"></input></acronym></rp>
      查看: 147|回復: 0
      上一主題 下一主題

      .NET Core對象池的應用:擴展篇

      79910

      主題

      0

      好友

      積分

      離線 發信

      跳轉到指定樓層
      樓主
      發表于 2021-09-17 10:50 | 只看該作者 | 倒序瀏覽
      目錄
      • 一、池化集合
      • 二、池化StringBuilder
      • 三、ArrayPool<T>
      • 四、MemoryPool<T>

             原則上所有的引用類型對象都可以通過對象池來提供,但是在具體的應用中需要權衡是否值得用。雖然對象池能夠通過對象復用的方式避免GC,但是它存儲的對象會耗用內存,如果對象復用的頻率很小,使用對象池是不值的。如果某個小對象的使用周期很短,能夠確保GC在第0代就能將其回收,這樣的對象其實也不太適合放在對象池中,因為第0代GC的性能其實是很高的。除此之外,對象釋放到對象池之后就有可能被其他線程提取出來,如果釋放的時機不對,有可能造成多個線程同時操作同一個對象??傊?,我們在使用之前得考慮當前場景是否適用對象池,在使用的時候嚴格按照“有借有還”、“不用才還”的原則。

      一、池化集合

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

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

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

      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

      我們知道,如果頻繁涉及針對字符串拼接的操作,應該使用StringBuilder以獲得更好的性能。實際上,StringBuilder對象自身也存在類似于列表對象的擴容問題,所以最好的方式就是利用對象池的方式來復用它們。對象池框架針對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);
              }
          }
      }
      
      

      如上面的代碼片段所示,我們直接可以調用ObjectPoolProvider的CreateStringBuilderPool擴展方法就可以得到針對StringBuilder的對象池對象(類型為ObjectPool<StringBuilder>)。我們上面演示實例一樣,我們指定的也是StringBuilder對象的初始和最大容量。池化StringBuilder對象的核心體現在對應的策略類型上,即如下這個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類型如出一轍。在默認情況下,池化StringBuilder對象的初始化和最大容量分別為100和5096。如下所示的是ObjectPoolProvider用于創建ObjectPool<StringBuilder>對象的兩個CreateStringBuilderPool擴展方法的定義。

      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>

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

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

      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方法從對象池中“借出”一個不小于(不是等于)指定長度的數組,該數組最終通過Return方法釋放到對象池。Return方法的clearArray參數表示在歸還數組之前是否要將其清空,這取決我們針對數組的使用方式。如果我們每次都需要覆蓋原始的內容,就沒有必要額外執行這種多余操作。

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

      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>

      數組是對托管堆中用于存儲同類對象的一段連續內存的表達,而另一個類型Memory<T>則具有更加廣泛的應用,因為它不僅僅可以表示一段連續的托管(Managed)內存,還可以表示一段連續的Native內存,甚至線程堆棧內存。具有如下定義的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>具有類似的定義,比如通過靜態屬性Shared獲取當前應用全局共享的MemoryPool<T>對象,通過Rent方法從對象池中借出一個不小于指定大小的Memory<T>對象。不同的是,MemoryPool<T>的Rent方法并沒有直接返回一個Memory<T>對象,而是一個封裝了該對象的IMemoryOwner<T>對象。MemoryPool<T>也沒有定義一個用來釋放Memory<T>對象的Reurn方法,這個操作是通過IMemoryOwner<T>對象的Dispose方法完成的。如果采用MemoryPool<T>,前面針對ArrayPool<T>的演示實例可以改寫成如下的形式。

      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對象池的應用:編程篇

      .NET Core對象池的應用:設計篇

      到此這篇關于.NET Core對象池的應用:擴展篇的文章就介紹到這了,更多相關.NET Core對象池的應用內容請搜索腳本之家以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持腳本之家!

      來源:http://www.jb51.net/article/221526.htm