Trong một buổi review code, mình thấy đoạn đọc file theo dòng kiểu này:

using var reader = new StreamReader(path);
string? line;
while ((line = await reader.ReadLineAsync()) != null)
{
    Process(line);
}

Nhìn sạch. Nhưng khi file log 2GB đi qua, con dotnet leo lên 1.8GB RAM và GC chạy liên tục. Lỗi không nằm ở StreamReader. Lỗi nằm ở chỗ mỗi dòng đọc ra là một chuỗi mới, và không có chỗ nào dùng lại bộ nhớ đó.

Đó là lý do ArrayPool<T> tồn tại. Nhưng mình cũng đã thấy pooling bị xài sai theo đủ kiểu, có kiểu làm ứng dụng trả về dữ liệu của người khác. Bài này nói cả hai mặt.

Vì sao .NET cần pool riêng

Bên Go có sync.Pool, dùng xong là GC tự dọn lúc nào cũng được, không ai phải nhớ. Bên .NET, mảng là đối tượng được quản lý, muốn "mượn rồi trả" thì phải có người nhớ trả. Không có cơ chế nào tự lấy lại.

ArrayPool<T>.Shared là cái kho dùng chung toàn tiến trình. Mượn bằng Rent(n), trả bằng Return(arr). Mượn nhanh, không cấp phát, không đẩy GC làm việc. Nhưng đổi lại, bạn phải giữ đúng luật của kho.

Luật thứ nhất: mảng trả về có thể DÀI HƠN bạn mượn

Đây là cái bẫy làm mình mất nửa buổi debug. Rent(100) không hứa trả mảng 100 phần tử. Nó trả một bucket gần nhất, có thể là 128.

var buffer = ArrayPool<byte>.Shared.Rent(100);
// buffer.Length có thể là 128

Nếu code của bạn ghi 100 byte rồi đem buffer đi so sánh, hash, hoặc Encoding.UTF8.GetString(buffer), phần đuôi 28 byte rác sẽ lọt vào kết quả. Không exception, không cảnh báo. Chỉ là dữ liệu sai, và sai một cách im lặng.

Cách viết đúng là luôn giữ độ dài thật riêng:

var buffer = ArrayPool<byte>.Shared.Rent(size);
try
{
    int read = await stream.ReadAsync(buffer.AsMemory(0, size));
    var usable = buffer.AsSpan(0, read);   // chỉ dùng tới đây
    Handle(usable);
}
finally
{
    ArrayPool<byte>.Shared.Return(buffer);
}

Mình thích Span ở chỗ này: nó không cho bạn vô tình dùng phần thừa, vì độ dài nằm trong chính cái span. Như đã nói ở bài Span trong .NET: cắt chuỗi mà không cấp phát, span là cách rẻ nhất để nói "tôi chỉ quan tâm đoạn này".

Luật thứ hai: bí mật vẫn nằm lại trong mảng

Mảng trả về kho không bị xoá. Người sau mượn đúng bucket đó sẽ nhận lại dữ liệu của bạn, nguyên vẹn.

Với dữ liệu thường thì chỉ là rác. Với JWT, mật khẩu, số thẻ thì là rò rỉ. Nên khi trả mảng có chứa dữ liệu nhạy cảm, phải xoá:

finally
{
    buffer.AsSpan(0, read).Clear();          // xoá đúng phần đã ghi
    ArrayPool<byte>.Shared.Return(buffer);
}

Mình đã thấy một API /login dùng pool để đọc body, trả mảng không xoá, rồi một endpoint khác đọc file ảnh mượn lại đúng bucket đó. Ảnh đầu tiên của mỗi ngày có thể chứa token của người trước. May là test phát hiện, nhưng bài học thì đắt.

Luật thứ ba: trả về đúng kho, đúng mảng

Ba cái sai hay gặp:

  • Mượn từ Shared nhưng trả về một ArrayPool<T>.Create() tự tạo. Hai kho khác nhau, mảng của kho này nhét sang kho kia, có khi bị ném ArgumentException, có khi lọt vào pool của pool khác.
  • Trả mảng đang còn được dùng. Ai viết Return(buffer) trước khi Span ra khỏi phạm vi là mời gọi race: chỗ khác mượn lại, ghi đè, trong khi code cũ vẫn đang đọc.
  • Trả nửa đường. yield return trong một iterator có try/finally đôi khi làm bạn tưởng finally chạy ngay, nhưng nó chỉ chạy khi iterator bị dispose. Nếu iterator lọt ra ngoài và không ai dispose, mảng không bao giờ về kho.

Dùng using với một wrapper nhỏ là cách gọn nhất để khỏi quên:

public ref struct PooledBuffer<T>
{
    private T[]? _array;
    public Span<T> Span => _array.AsSpan(0, Length);
    public int Length { get; }

    public PooledBuffer(int size)
    {
        _array = ArrayPool<T>.Shared.Rent(size);
        Length = size;
    }

    public void Dispose()
    {
        if (_array is null) return;
        _array.AsSpan(0, Length).Clear();
        ArrayPool<T>.Shared.Return(_array);
        _array = null;
    }
}

ref struct ở đây không phải để khoe. Nó chặn bạn nhét cái buffer vào một field của class hay capture vào lambda async, tức là chặn luôn kiểu dùng sống lâu hơn vòng đời của nó.

Khi nào KHÔNG nên pool

Đây là phần mình thấy thiếu trong hầu hết bài viết về ArrayPool.

Pool chỉ thắng khi có nhiều vòng mượn-trả với kích thước ổn định và vòng đời ngắn. Nếu mỗi request mượn một mảng lớn khác cỡ nhau, Shared sẽ giữ lại bucket to nhất rất lâu, và bạn có một dạng rò rỉ mềm: RAM không xuống dù tải đã giảm. Gặp trường hợp đó, dùng ArrayPool<T>.Create(maxArrayLength, maxArraysPerBucket) riêng cho từng loại workload để nó không vác bucket của thằng khác.

Nếu mảng sống lâu hơn một method, hoặc nằm trong object trả về cho tầng khác, đừng pool. Bạn sẽ phải truyền trách nhiệm trả mảng qua năm tầng code, và tầng thứ sáu sẽ quên.

Và nhớ điều này: pool không làm code nhanh hơn một cách thần kỳ. Nó chỉ bỏ bớt việc cấp phát. Với đường nóng như đọc socket, ghi file, serialize thì đáng. Với một vòng lặp 20 phần tử trong một request/giây thì là tự làm khó mình. Cũng như LINQ deferred execution: query chạy lại mỗi lần bạn duyệt — cái đáng sửa là chỗ chạy nhiều, không phải chỗ trông dài.

Đo lại sau khi sửa

Sau khi thay ReadLineAsync bằng đọc block qua Rent, cùng file 2GB:

  • RAM đỉnh: 1.8GB → 120MB.
  • Thời gian chạy nhanh hơn khoảng 30%, vì bớt cấp phát chuỗi cho từng dòng.
  • GC gen 0 giảm gần 95%.

Nhưng lần đo đầu tiên lại chậm hơn. Lý do: mình mượn mảng mới cho mỗi dòng, nên cái pool thành một cái máy xay thêm việc. Sửa một chỗ là mượn một lần cho cả file rồi đọc lại từng đoạn trong đó.

Nên nhớ: benchmark trước, sửa, benchmark lại. Tin vào con số, đừng tin vào cảm giác "chắc là nhanh hơn". Nếu bạn có câu query đang bắn hàng chục lần một trang, xem EF Core N+1: 1 trang bắn 51 query và cách sửa trước — sửa chỗ đó thường lời hơn cả tháng tối ưu bộ nhớ.

📋 Phụ lục thuật ngữ

  • ArrayPool: kho mảng dùng chung, mượn bằng Rent, trả bằng Return, tránh cấp phát mới.
  • Bucket: nhóm mảng cùng cỡ trong pool. Rent(100) có thể trả mảng 128 vì nằm cùng bucket.
  • Span / Memory: view trên một vùng bộ nhớ, mang theo độ dài, không copy dữ liệu.
  • Gen 0 / GC: thế hệ bộ nhớ ngắn hạn nhất; cấp phát nhiều thì gen 0 chạy nhiều, tốn CPU.
  • ref struct: kiểu chỉ sống trên stack, không bị box, không nhét vào field của class.

Xem các bài viết khác