C#.NET ArrayPool 深入解析：高性能內存池的實現與應用 Detail - c#,.net 唐青楓 Blog

簡介

ArrayPool<T> 是 .NET 中一個高性能的內存管理工具，位於 System.Buffers 命名空間。它通過重用數組而非頻繁分配新數組，顯著減少 GC（垃圾回收）壓力，提升內存敏感型應用的性能。特別適合處理大型數組和臨時緩衝區。

工作原理圖解

背景與動機

GC 和大對象開銷：頻繁分配與釋放大數組（特別是超過 LOH 閾值 ~85 KB 的數組）會導致大量垃圾回收壓力和內存碎片化，影響吞吐和響應延遲。
重用與零分配：通過在運行時複用已有數組，避免重複的堆分配和回收開銷。
通用、高性能：ArrayPool<T> 提供了線程安全、可配置的數組池，實現零散內存的集中管理，適用於高性能場景如網絡協議解析、圖像處理、流式 IO 等。

主要功能

數組租用：通過 Rent 方法從池中獲取指定大小的數組。
數組歸還：通過 Return 方法將數組歸還到池中以供複用。
共享和自定義池：提供默認的共享池（ArrayPool<T>.Shared）和支持自定義池（ArrayPool<T>.Create）。
線程安全：內置線程安全機制，適合多線程環境。
泛型支持：支持任意類型的數組（如 byte[]、int[] 等）。

功能	描述
`ArrayPool<T>.Shared`	獲取全局共享的靜態池實例
`ArrayPool<T>.Create(...)`	創建自定義配置的獨立池，可指定最大數組長度和池大小
`Rent(int minimumLength)`	從池中租用至少 `minimumLength` 大小的數組
`Return(T[] array, bool clearArray = false)`	將數組歸還給池，可選擇是否清零以防泄漏上一輪數據

支持環境與安裝

框架
- .NET Core 2.1+（內置於 System.Buffers）
- .NET 5/6/7/8/9
- .NET Standard 2.0+（可通過 NuGet 引用 System.Buffers）
- .NET Framework 4.6.1+（需安裝 System.Buffers 包）
安裝（僅限舊版或 .NET Framework）

Install-Package System.Buffers

引用命名空間

using System.Buffers;

基本使用

using System;
using System.Buffers;

class Program
{
    static void Main()
    {
        // 從共享池租用至少 1024 個字節的數組
        byte[] buffer = ArrayPool<byte>.Shared.Rent(1024);

        try
        {
            // 使用數組
            for (int i = 0; i < 100; i++)
            {
                buffer[i] = (byte)i;
            }
            Console.WriteLine($"First byte: {buffer[0]}");
        }
        finally
        {
            // 歸還數組
            ArrayPool<byte>.Shared.Return(buffer);
        }
    }
}

Rent(1024) 返回一個至少 1024 字節的數組（可能更大，如 2048 字節，取決於池的桶策略）。
使用 try-finally 確保數組始終歸還，避免內存泄漏。

主要 API 用法

獲取實例

// 最常用：全局共享池
var pool = ArrayPool<byte>.Shared;

// 定製池：最大保留 100 個 ≤1 024 長度的數組
var customPool = ArrayPool<byte>.Create(maxArrayLength: 1024, maxArraysPerBucket: 100);

租用數組

// 租用至少 4096 個元素的 byte 數組
byte[] buffer = pool.Rent(4096);

// 注意：獲得的數組長度可能 ≥ requested；請僅使用 [0..requestedLength) 區間
int needed = 4096;
int actualLength = buffer.Length;  // 可能大於 needed

使用數組

// 例如從網絡流讀取
int bytesRead = await stream.ReadAsync(buffer, 0, needed);
Process(buffer, bytesRead);

歸還數組

// 歸還時可選擇是否清零已使用區，默認為 false
pool.Return(buffer, clearArray: true);

與 Span/Memory 集成

using System.Buffers;

public async Task ProcessStreamAsync(Stream stream)
{
    byte[] buffer = ArrayPool<byte>.Shared.Rent(8192);
    try
    {
        int bytesRead = await stream.ReadAsync(buffer.AsMemory(0, 8192));
        Span<byte> data = buffer.AsSpan(0, bytesRead);
        // 處理數據
        Console.WriteLine($"Read {bytesRead} bytes");
    }
    finally
    {
        ArrayPool<byte>.Shared.Return(buffer);
    }
}

説明：AsMemory 和 AsSpan 允許零拷貝操作，適合 I/O 操作。

線程安全

ArrayPool<T> 是線程安全的，可在多線程環境中使用：

Parallel.For(0, 10, i =>
{
    byte[] buffer = ArrayPool<byte>.Shared.Rent(1024);
    try
    {
        // 使用數組
    }
    finally
    {
        ArrayPool<byte>.Shared.Return(buffer);
    }
});

實現原理

池化機制：
- ArrayPool<T> 維護一個內部數組池，分為多個“桶”（buckets），每個桶存儲特定大小範圍的數組（如 16、32、64 字節等）。
- 桶大小通常按 2 的冪次增長（如 16、32、64、128...），以優化內存分配。
租用和歸還：
- Rent：從適合的桶中獲取數組，若無可用數組則分配新數組。
- Return：將數組放回對應桶，若桶已滿則丟棄（交給 GC）。
共享池：
- ArrayPool<T>.Shared 是一個單例池，維護全局共享的數組集合。
- 使用分層桶（per-core buckets）支持線程本地存儲，減少鎖競爭。
自定義池：
- 允許開發者控制桶大小和數組數量，適合特定場景優化。
GC 交互：
- 歸還的數組不立即釋放，而是保留在池中供複用，降低 GC 壓力。
- 如果池中數組過多或大小超出限制，數組可能被 GC 回收。

使用場景

網絡 I/O 緩衝區

在讀寫 NetworkStream、Socket 或 HttpClient 時，頻繁申請大塊緩衝區會觸發 LOH 分配。
使用 ArrayPool<byte>.Shared.Rent(bufferSize) 來租用緩衝區，讀完後歸還，顯著降低 GC 觸發次數。

// 處理網絡數據包
async Task ProcessNetworkStream(NetworkStream stream)
{
    ArrayPool<byte> pool = ArrayPool<byte>.Shared;
    byte[] buffer = pool.Rent(4096); // 租用4KB緩衝區
    
    try
    {
        int bytesRead;
        while ((bytesRead = await stream.ReadAsync(buffer)) > 0)
        {
            // 僅處理實際讀取部分
            var dataSpan = new ReadOnlySpan<byte>(buffer, 0, bytesRead);
            ParsePacket(dataSpan);
        }
    }
    finally
    {
        pool.Return(buffer); // 確保歸還
    }
}

文件/流式讀取與寫入

處理大文件或日誌時，一次性讀取或寫入數十 KB、數百 KB，避免每次 new 數組帶來的開銷。
示例：分塊讀取大型日誌文件並逐塊處理。

void ProcessLargeFile(string path)
{
    using var fs = File.OpenRead(path);
    ArrayPool<byte> pool = ArrayPool<byte>.Shared;
    byte[] buffer = pool.Rent(1024 * 1024); // 1MB緩衝
    
    try
    {
        int bytesRead;
        while ((bytesRead = fs.Read(buffer)) > 0)
        {
            // 使用Span避免額外複製
            var chunk = buffer.AsSpan(0, bytesRead);
            CompressData(chunk);
        }
    }
    finally
    {
        pool.Return(buffer);
    }
}

JSON/XML 序列化與反序列化

大型對象圖（或批量數據）在 JsonSerializer 內部會申請中等大小緩衝區用於拼接文本。
可以自定義 IBufferWriter<byte>，從 ArrayPool<byte> 獲取底層緩衝，減少中間分配。

byte[] SerializeToJson<T>(T obj)
{
    ArrayPool<byte> pool = ArrayPool<byte>.Shared;
    byte[] buffer = pool.Rent(initialSize: 1024);
    
    try
    {
        using var ms = new MemoryStream(buffer);
        JsonSerializer.Serialize(ms, obj);
        
        // 返回精確大小的副本
        return buffer[..(int)ms.Position];
    }
    finally
    {
        pool.Return(buffer);
    }
}

Socket 通信

async Task ProcessSocketAsync(Socket socket)
{
    var pool = ArrayPool<byte>.Shared;
    byte[] buffer = pool.Rent(4096); // 租用4KB緩衝區
    
    try
    {
        int received;
        while ((received = await socket.ReceiveAsync(buffer, SocketFlags.None)) > 0)
        {
            // 處理接收的數據
            ProcessData(buffer.AsSpan(0, received));
        }
    }
    finally
    {
        pool.Return(buffer); // 歸還緩衝區
    }
}

HTTP請求處理

public async Task<string> ReadResponseContentAsync(HttpResponseMessage response)
{
    var pool = ArrayPool<byte>.Shared;
    byte[] buffer = pool.Rent(8192); // 8KB緩衝區
    StringBuilder content = new StringBuilder();

    try
    {
        using var stream = await response.Content.ReadAsStreamAsync();
        int bytesRead;
        while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length)) > 0)
        {
            content.Append(Encoding.UTF8.GetString(buffer, 0, bytesRead));
        }
        return content.ToString();
    }
    finally
    {
        pool.Return(buffer);
    }
}

文件壓縮/解壓縮

byte[] CompressData(byte[] input)
{
    var pool = ArrayPool<byte>.Shared;
    byte[] buffer = pool.Rent(8192); // 8KB壓縮緩衝區
    
    try
    {
        using var outputStream = new MemoryStream();
        using var compressStream = new GZipStream(outputStream, CompressionMode.Compress);
        
        compressStream.Write(input, 0, input.Length);
        compressStream.Flush();
        
        return outputStream.ToArray();
    }
    finally
    {   
        pool.Return(buffer);
    }
}

批量數據轉換

byte[] ConvertEncoding(byte[] source, Encoding from, Encoding to)
{
    var pool = ArrayPool<byte>.Shared;
    byte[] buffer = pool.Rent(source.Length);
    
    try
    {
        // 編碼轉換
        char[] chars = from.GetChars(source);
        int byteCount = to.GetBytes(chars, buffer);
        
        // 返回轉換結果
        byte[] result = new byte[byteCount];
        Array.Copy(buffer, result, byteCount);
        return result;
    }
    finally
    {
        pool.Return(buffer);
    }
}

CSV/Excel數據處理

void ProcessCsvFile(Stream csvStream)
{
    var pool = ArrayPool<char>.Shared;
    char[] buffer = pool.Rent(4096); // 4K字符緩衝區
    
    try
    {
        using var reader = new StreamReader(csvStream);
        int charsRead;
        while (!reader.EndOfStream)
        {
            charsRead = reader.Read(buffer, 0, buffer.Length);
            ProcessCsvChunk(buffer.AsSpan(0, charsRead));
        }
    }
    finally
    {
        pool.Return(buffer);
    }
}

AES加密操作

byte[] EncryptAes(byte[] plaintext, byte[] key)
{
    var pool = ArrayPool<byte>.Shared;
    byte[] buffer = pool.Rent(plaintext.Length + 16); // 額外空間用於填充
    
    try
    {
        using var aes = Aes.Create();
        aes.Key = key;
        aes.GenerateIV();
        
        int encryptedBytes;
        using (var encryptor = aes.CreateEncryptor())
        {
            encryptedBytes = encryptor.TransformBlock(
                plaintext, 0, plaintext.Length, buffer, 0);
        }
        
        // 組合結果：IV + 加密數據
        byte[] result = new byte[aes.IV.Length + encryptedBytes];
        Buffer.BlockCopy(aes.IV, 0, result, 0, aes.IV.Length);
        Buffer.BlockCopy(buffer, 0, result, aes.IV.Length, encryptedBytes);
        
        return result;
    }
    finally
    {
        pool.Return(buffer);
    }
}

密碼哈希計算

byte[] ComputePasswordHash(string password, byte[] salt)
{
    var pool = ArrayPool<byte>.Shared;
    
    // 計算所需緩衝區大小
    int byteCount = Encoding.UTF8.GetByteCount(password);
    byte[] buffer = pool.Rent(byteCount + salt.Length);
    
    try
    {
        // 將密碼和鹽複製到緩衝區
        Encoding.UTF8.GetBytes(password, buffer);
        Buffer.BlockCopy(salt, 0, buffer, byteCount, salt.Length);
        
        // 計算哈希
        return SHA256.HashData(buffer.AsSpan(0, byteCount + salt.Length));
    }
    finally
    {
        pool.Return(buffer);
    }
}

圖像／聲音／視頻處理

編解碼或濾鏡操作需要訪問像素／樣本數組，多次分配會嚴重影響實時性能。
租用一個足夠大的 T[] 池，重複利用，提升幀處理吞吐。

void ProcessImagePixels(Bitmap image)
{
    var pool = ArrayPool<byte>.Shared;
    
    // 計算緩衝區大小（像素數 * 每個像素字節數）
    int bufferSize = image.Width * image.Height * 4; // RGBA格式
    byte[] buffer = pool.Rent(bufferSize);
    
    try
    {
        // 將像素複製到緩衝區
        var bitmapData = image.LockBits(/* ... */);
        Marshal.Copy(bitmapData.Scan0, buffer, 0, bufferSize);
        image.UnlockBits(bitmapData);
        
        // 處理像素數據
        ProcessPixels(buffer.AsSpan(0, bufferSize));
        
        // 複製回圖像
        Marshal.Copy(buffer, 0, bitmapData.Scan0, bufferSize);
    }
    finally
    {
        pool.Return(buffer);
    }
}

文本處理與字符緩衝

使用 Span<char> 或 Memory<char> 拼接大段文本、正則匹配、語法分析等場景。
通過 ArrayPool<char> 租用臨時字符緩衝，減少 StringBuilder 擴容次數。

高併發隊列／管道（Pipelines）

在 System.IO.Pipelines 或自定義流水線中傳遞數據塊，Pool 模式能統一管理內存，避免碎片化。
租用後寫入管道，消費端處理完歸還。

臨時大數組計算

大規模矩陣乘法、FFT、統計分析等算法中，需要一次性申請幾 MB 數組用於中間計算。
將這些中間緩衝改為池化數組，可減少內存波動，保持長期穩定性能。

float[] MatrixMultiplication(float[,] a, float[,] b)
{
    int rows = a.GetLength(0);
    int cols = b.GetLength(1);
    int inner = a.GetLength(1);
    
    var pool = ArrayPool<float>.Shared;
    float[] resultBuffer = pool.Rent(rows * cols);
    
    try
    {
        // 使用Span進行高效矩陣乘法
        var resultSpan = resultBuffer.AsSpan();
        
        for (int i = 0; i < rows; i++)
        {
            for (int k = 0; k < inner; k++)
            {
                float temp = a[i, k];
                for (int j = 0; j < cols; j++)
                {
                    resultSpan[i * cols + j] += temp * b[k, j];
                }
            }
        }
        
        // 返回結果副本
        float[] result = new float[rows * cols];
        resultSpan[..result.Length].CopyTo(result);
        return result;
    }
    finally
    {
        pool.Return(resultBuffer);
    }
}

大數據集合處理

void ProcessLargeDataset(IEnumerable<DataRecord> records)
{
    var pool = ArrayPool<DataRecord>.Shared;
    const int batchSize = 1000;
    DataRecord[] buffer = pool.Rent(batchSize);
    
    try
    {
        int index = 0;
        foreach (var record in records)
        {
            buffer[index++] = record;
            
            if (index >= batchSize)
            {
                ProcessBatch(buffer.AsSpan(0, batchSize));
                index = 0;
            }
        }
        
        // 處理剩餘記錄
        if (index > 0)
        {
            ProcessBatch(buffer.AsSpan(0, index));
        }
    }
    finally
    {
        pool.Return(buffer);
    }
}

自定義緩衝區池

如果某種特定大小的緩衝區（如 1024、4096、16384）申請頻率極高，可創建專屬 ArrayPool<T>.Create(...)，精細控制池容量和分桶策略。

不適用 ArrayPool 的場景

長期持有數據（> 分鐘級）
超小數組（< 1KB）
複雜對象數組

優缺點

優點

高性能：減少內存分配和 GC 開銷，適合高吞吐量場景。
線程安全：內置支持多線程，無需額外同步。
靈活性：支持任意類型數組，結合 Span<T> 和 Memory<T> 提供現代內存操作。
共享池：ArrayPool<T>.Shared 提供開箱即用的全局池。
自定義池：允許精細控制內存使用，適合特定場景。

缺點

手動管理：開發者必須顯式調用 Return，否則可能導致內存泄漏。
數組大小不精確：Rent 返回的數組可能比請求的大，需檢查實際大小。
清空開銷：clearArray = true 會增加性能開銷。
有限的桶大小：共享池的桶大小固定，可能不適合極端的數組大小需求。
學習曲線：需理解池化機制和 Span<T>/Memory<T> 的使用。

與其他工具的對比

與普通數組（`new T[]`）

普通數組：每次分配新數組，增加 GC 壓力，適合小規模或長期使用的場景。
ArrayPool<T>：複用數組，減少分配和 GC，適合臨時、頻繁使用的場景。

與 `List<T>`

List<T>：動態調整大小，適合需要動態增長的場景，但頻繁擴容會導致性能開銷。
ArrayPool<T>：固定大小，適合已知大小的臨時緩衝區，性能更高。

與 `MemoryPool<T>`

MemoryPool<T>：更通用，管理任意內存塊（不僅限於數組），返回 IMemoryOwner<T>。
ArrayPool<T>：專注於數組，API 更簡單，適合大多數緩衝區場景。
選擇建議：優先使用 ArrayPool<T>，除非需要非數組內存（如自定義緩衝區）。

使用注意事項

邊界管理
- 僅使用有效區間：Rent(n) 返回的數組長度可能 > n，切勿訪問或依賴額外元素的初始值。
- 勿跨越歸還後重用：一旦調用 Return，立即停止對該數組的任何讀寫操作。
安全性
- 敏感數據：若數組中含有敏感信息（如密碼、密鑰、個人隱私），歸還前務必傳入 clearArray: true，以刪除殘留數據。
- 併發歸還：同一個數組實例絕不能被多次歸還或同時歸還；否則會破壞池的內部結構。
池配置
- 對於大小集中的場景，可使用全局 Shared 池；對特殊長度或池容量有嚴格需求的，建議自行 Create 並控制參數。
- maxArrayLength 參數限制了池中單個數組的最大允許長度；若請求超出此值，Rent 將直接 new 並不入池。
內存佔用
- 池會緩存若干對象以應對下次租用，但不會無限制膨脹；不同實現可能對“水桶”數量和每桶容量有默認策略。
- 在極端內存受限場景，應評估並監控池的默認行為或採用自定義實現。

替代方案對比

方案	適用場景	與ArrayPool比較
stackalloc	小型棧分配數組	更高效但大小受限(1MB)
NativeMemory	非託管內存	更底層，無GC但需手動管理
MemoryPool	I/O管道緩衝區	面向Span/Memory的抽象
new[]	長期持有數組	簡單但GC壓力大

經驗法則：應用存在以下情況時，考慮使用 ArrayPool

頻繁分配/回收超過 1KB 的數組

遇到垃圾回收 (GC) 性能問題

處理大型數據集或高吞吐量數據流

在內存受限環境中運行

ASP.NET Core 示例

using Microsoft.AspNetCore.Mvc;
using System.Buffers;
using System.IO;
using System.Threading.Tasks;

[ApiController]
[Route("api/data")]
public class DataController : ControllerBase
{
    [HttpPost]
    public async Task<IActionResult> ProcessData()
    {
        byte[] buffer = ArrayPool<byte>.Shared.Rent(8192);
        try
        {
            using var ms = new MemoryStream();
            int bytesRead;
            while ((bytesRead = await Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0)
            {
                await ms.WriteAsync(buffer, 0, bytesRead);
            }
            // 處理 ms 中的數據
            return Ok($"Processed {ms.Length} bytes");
        }
        finally
        {
            ArrayPool<byte>.Shared.Return(buffer);
        }
    }
}

唐青楓 Blog

@tangqingfeng

Tags

php (185)

Linux (168)

HTTP (69)

c# (66)

.net (57)

intellij-idea (54)

Git (53)

設計模式 (50)

ide (27)

vim (20)

yii2 (20)

composer (19)

Stories

C#.NET ArrayPool 深入解析：高性能內存池的實現與應用 - Stories Detail

簡介

工作原理圖解

背景與動機

主要功能

支持環境與安裝

基本使用

主要 API 用法

獲取實例

租用數組

使用數組

歸還數組

與 Span/Memory 集成

線程安全

實現原理

使用場景

網絡 I/O 緩衝區

文件/流式讀取與寫入

JSON/XML 序列化與反序列化

Socket 通信

HTTP請求處理

文件壓縮/解壓縮

批量數據轉換

CSV/Excel數據處理

AES加密操作

密碼哈希計算

圖像／聲音／視頻處理

文本處理與字符緩衝

高併發隊列／管道（Pipelines）

臨時大數組計算

大數據集合處理

自定義緩衝區池

不適用 ArrayPool 的場景

優缺點

與其他工具的對比

與普通數組（new T[]）

與 List<T>

與 MemoryPool<T>

使用注意事項

替代方案對比

ASP.NET Core 示例

Add a new Comments

與普通數組（`new T[]`）

與 `List<T>`

與 `MemoryPool<T>`