[[420806]]

一：背景

1. 講故事

最近在分析一個 dump 的過程中發現其在 gen2 和 LOH 上有不少size較大的free，仔細看了下，這些free生前大多都是模板引擎生成的html片段的byte[]數組，當然這篇我不是來分析dump的，而是來聊一下，當托管堆有很多length較大的 byte[] 數組時，如何讓內存利用更高效，如何讓gc老先生壓力更小。

不知道大家有沒有發現在 .netcore 中增加了不少池化對象的東西，比如：ArrayPool，ObjectPool 等等，確實在某些場景下還是特別實用的，所以有必要對其進行較深入的理解。

二：ArrayPool 源碼分析

1. 一圖勝千言

在我花了將近一個小時的源碼閱讀之后，我畫了一張 ArrayPool 的池化圖，所謂：一圖在手,天下我有 。

有了這張圖，接下來再聊幾個概念并配上相應源碼，我覺得應該就差不多了。

2. 池化的架構分級是什么樣的?

ArrayPool 是由若干個 Bucket 組成， 而 Bucket 又由若干個 buffer[] 數組組成, 有了這個概念之后，再配一下代碼。

public abstract class ArrayPool<T> 
{ 
    public static ArrayPool<T> Create() 
    { 
        return new ConfigurableArrayPool<T>(); 
    } 
} 
 
internal sealed class ConfigurableArrayPool<T> : ArrayPool<T> 
{ 
    private sealed class Bucket 
    { 
        internal readonly int _bufferLength; 
        private readonly T[][] _buffers; 
        private int _index; 
    } 
 
    private readonly Bucket[] _buckets;     //bucket數組 
} 

3. 為什么每一個 bucket 里都有 50 個 buffer[]

這個問題很好回答，初始化時做了 maxArraysPerBucket=50 設定，當然你也可以自定義，具體參考如下代碼：

internal sealed class ConfigurableArrayPool<T> : ArrayPool<T> 
{ 
    internal ConfigurableArrayPool() : this(1048576, 50) 
    { 
    } 
 
    internal ConfigurableArrayPool(int maxArrayLength, int maxArraysPerBucket) 
    { 
        int num = Utilities.SelectBucketIndex(maxArrayLength); 
        Bucket[] array = new Bucket[num + 1]; 
        for (int i = 0; i < array.Length; i++) 
        { 
            array[i] = new Bucket(Utilities.GetMaxSizeForBucket(i), maxArraysPerBucket, id); 
        } 
        _buckets = array; 
    } 
} 

4. bucket 中 buffer[].length 為什么依次是 16，32，64 ...

框架做了默認假定，第一個bucket中的 buffer[].length=16, 后續 bucket 中的 buffer[].length 都是 x2 累計，涉及到代碼就是 GetMaxSizeForBucket() 方法，參考如下：

internal ConfigurableArrayPool(int maxArrayLength, int maxArraysPerBucket) 
{ 
    Bucket[] array = new Bucket[num + 1]; 
    for (int i = 0; i < array.Length; i++) 
    { 
        array[i] = new Bucket(Utilities.GetMaxSizeForBucket(i), maxArraysPerBucket, id); 
    } 
} 
 
internal static int GetMaxSizeForBucket(int binIndex) 
{ 
    return 16 << binIndex; 
} 

5. 初始化時 bucket 到底有多少個?

其實在上圖中我也沒有給出 bucket 到底有多少個，那到底是多少個呢??????? ，當我閱讀完源碼之后，這算法還挺有意思的。

先說一下結果吧，默認 17 個 bucket，你肯定會好奇怎么算的?先說下兩個變量：

• maxArrayLength=1048576 = 2的20次方
• buffer.length= 16 = 2的4次方

最后的算法就是取次方的差值：bucket[].length= 20 - 4 + 1 = 17，換句話說最后一個 bucket 下的 buffer[].length=1048576，詳細代碼請參考 SelectBucketIndex() 方法。

internal sealed class ConfigurableArrayPool<T> : ArrayPool<T> 
{ 
    internal ConfigurableArrayPool(): this(1048576, 50) 
    { } 
 
    internal ConfigurableArrayPool(int maxArrayLength, int maxArraysPerBucket) 
    { 
        int num = Utilities.SelectBucketIndex(maxArrayLength); 
        Bucket[] array = new Bucket[num + 1]; 
        for (int i = 0; i < array.Length; i++) 
        { 
            array[i] = new Bucket(Utilities.GetMaxSizeForBucket(i), maxArraysPerBucket, id); 
        } 
        _buckets = array; 
    } 
 
    internal static int SelectBucketIndex(int bufferSize) 
    { 
        return BitOperations.Log2((uint)(bufferSize - 1) | 0xFu) - 3; 
    } 
} 

到這里我相信你對 ArrayPool 的池化架構思路已經搞明白了，接下來看下如何申請和歸還 buffer[]。

三：如何申請和歸還

既然 buffer[] 做了顆粒化，那就應該好借好還，反應到代碼上就是 Rent() 和 Return() 方法，為了方便理解，上代碼說話：

class Program 
{ 
    static void Main(string[] args) 
    { 
        var arrayPool = ArrayPool<int>.Create(); 
 
        var bytes = arrayPool.Rent(10); 
 
        for (int i = 0; i < bytes.Length; i++) bytes[i] = 10; 
 
        arrayPool.Return(bytes); 
 
        Console.ReadLine(); 
    } 
} 

有了代碼和圖之后，再稍微捋一下流程。

從 ArrayPool 中借一個 byte[10] 大小的數組，為了節省內存，先不備貨，臨時生成一個 byte[].size=16 的數組出來，簡化后的代碼如下，參考 if (flag) 處：

internal T[] Rent() 
   { 
       T[][] buffers = _buffers; 
       T[] array = null; 
       bool lockTaken = false; 
       bool flag = false; 
       try 
       { 
           if (_index < buffers.Length) 
           { 
               array = buffers[_index]; 
               buffers[_index++] = null; 
               flag = array == null; 
           } 
       } 
       if (flag) 
       { 
           array = new T[_bufferLength]; 
       } 
       return array; 
   } 

這里有一個坑，那就是你以為借了 byte[10]，現實給你的是 byte[16]，這里稍微注意一下。

當用 ArrayPool.Return 歸還 byte[16] 時, 很明顯看到它落到了第一個bucket的第一個buffer[]上，參考如下簡化后的代碼：

internal void Return(T[] array) 
  { 
      if (_index != 0) 
      { 
          _buffers[--_index] = array; 
      } 
  } 

這里也有一個值得注意的坑，那就是還回去的 byte[16] 里面的數據默認是不會清掉的，從上面的代碼也是可以看出來的，要想做清理，需要在 Return 方法中指定 clearArray=true，參考如下代碼：

public override void Return(T[] array, bool clearArray = false) 
  { 
      int num = Utilities.SelectBucketIndex(array.Length); 
 
      if (num < _buckets.Length) 
      { 
          if (clearArray) 
          { 
              Array.Clear(array, 0, array.Length); 
          } 
          _buckets[num].Return(array); 
      } 
  } 

四：總結

學習這其中的 池化架構 思想，對平時項目開發還是能提供一些靈感的，其次對那些一次性使用 byte[] 的場景，用池化是個非常不錯的方法，這也是我對朋友dump分析后提出的一個優化思路。

本文轉載自微信公眾號「一線碼農聊技術」，可以通過以下二維碼關注。轉載本文請聯系一線碼農聊技術公眾號。