0

Async/await trong ASP.NET Core: vì sao API treo cứng khi tải tăng

Hơn 9 giờ sáng, giờ cao điểm. Dashboard báo response time của API đơn hàng vọt từ vài trăm mili giây lên cả chục giây, request timeout liên tục. Mở metric ra thì lạ: CPU chưa tới 20%, RAM bình thường, database rảnh rang. Server không làm gì cả, mà request cứ xếp hàng.

Thủ phạm hoá ra là một chữ .Result nằm trong một controller. Bài này kể lại cách mình lần ra nó, và mấy cái bẫy async/await khác trong ASP.NET Core mà code nhìn vô hại nhưng lên prod là chết.

Phản xạ đầu tiên: scale thêm máy

Request chậm thì thêm instance, ai cũng nghĩ vậy. Mình tăng từ 2 lên 4 instance. Đỡ được chừng mười phút, rồi đâu lại vào đấy.

Lúc đó mình mới chịu ngồi nhìn kỹ cái triệu chứng: CPU thấp mà response time cao. Server không bận tính toán, nó đang chờ. Mà chờ thì thêm máy chỉ là thêm chỗ để chờ.

Đo cho đúng: thread pool đang nghẹt

ASP.NET Core xử lý request trên thread pool. Mỗi request mượn một thread, xong việc thì trả lại. Nếu thread bị giữ mà không làm gì, thread pool cạn dần, request mới phải đứng xếp hàng chờ có thread rảnh. Hiện tượng này gọi là thread pool starvation.

Cách kiểm tra nhanh nhất là dotnet-counters:

dotnet tool install --global dotnet-counters
dotnet-counters monitor --process-id <pid> --counters System.Runtime

Hai chỉ số cần nhìn là độ dài hàng đợi của thread pool và số thread của thread pool. Trên .NET 8 chúng tên là ThreadPool Queue Length và ThreadPool Thread Count; từ .NET 9 đổi thành dotnet.thread_pool.queue.length và dotnet.thread_pool.thread.count. Hàng đợi cứ dài ra trong khi số thread tăng lèo tèo từng chút một, CPU thì thấp: gần như chắc là starvation. Thread pool không bung thêm hàng trăm thread ngay lập tức, nó thêm từ từ, nên khi bị nghẹt thì hồi lại rất chậm.

Biết là nghẹt rồi thì phải biết các thread đang kẹt ở đâu. dotnet-stack in stack của mọi thread đang chạy:

dotnet tool install --global dotnet-stack
dotnet-stack report --process-id <pid>

Trong đống stack đó, hàng chục thread cùng dừng ở một chỗ: Task.Wait / GetResult được gọi từ OrderController.GetOrder.

Thủ phạm: một chữ .Result

Code lúc đó trông thế này:

[HttpGet("{id}")]
public IActionResult GetOrder(int id)
{
    // Gọi hàm async rồi chặn lại chờ kết quả: thread đứng im suốt thời gian chờ
    var order = _orderService.GetOrderAsync(id).Result;
    var shipping = _shippingClient.GetStatusAsync(order.TrackingCode).Result;
    return Ok(new { order, shipping });
}

Service bên dưới đã viết async đàng hoàng, chỉ có controller là "lười" không đổi chữ ký. Hồi viết nó chạy ngon, test cũng ngon, vì lúc test chỉ có vài request. Còn GetStatusAsync gọi sang API bên vận chuyển, bình thường trả lời trong 200ms. Sáng hôm đó bên vận chuyển chậm lên 5 giây, và mỗi request giữ chặt một thread suốt 5 giây đó chỉ để... chờ.

Kiểu viết này gọi là sync-over-async. Đã gọi hàm async thì await nó:

[HttpGet("{id}")]
public async Task<IActionResult> GetOrder(int id, CancellationToken ct)
{
    var order = await _orderService.GetOrderAsync(id, ct);
    if (order is null) return NotFound();

    // Trong lúc chờ API vận chuyển, thread được trả về pool để phục vụ request khác
    var shipping = await _shippingClient.GetStatusAsync(order.TrackingCode, ct);
    return Ok(new { order, shipping });
}

Khi await một thao tác I/O, thread không đứng chờ. Nó được trả về thread pool, khi có kết quả thì một thread nào đó nhặt lên chạy tiếp. Cùng số thread đó phục vụ được nhiều request hơn hẳn.

Nhân tiện: nhiều người sợ .Result vì "gây deadlock". Đúng với ASP.NET cũ trên .NET Framework và app WinForms/WPF, vì ở đó có SynchronizationContext. ASP.NET Core không có SynchronizationContext, nên .Result thường không deadlock. Nó chỉ âm thầm ăn thread, và chính vì không deadlock nên lúc dev chẳng ai thấy gì bất thường.

Mấy cái bẫy khác cùng họ

async void

// Sai: exception trong hàm này không ai bắt được, có thể làm sập cả process
public async void SendWelcomeEmail(User user)
{
    await _mailer.SendAsync(user.Email, "Chào mừng");
}

Hàm async void không trả về Task, nên người gọi không await được và không biết nó lỗi. Exception bắn ra trong đó không có ai bắt, rơi thẳng ra thread pool, và process chết. Lúc đó log chỉ thấy app tự restart.

Trả về Task là xong. async void chỉ nên dùng cho event handler, mà trong Web API gần như chẳng có event handler nào. Còn nếu lý do viết async void là vì muốn "bắn xong quên", không chờ gửi mail, thì đó là chuyện của background job, mình để dành cho một bài sau trong series.

Không truyền CancellationToken

User bấm F5 hay đóng app, request cũ bị huỷ phía client, nhưng server vẫn hì hục chạy query, gọi API cho một response không ai nhận. Lúc tải cao, đống việc thừa này cộng dồn lại không nhỏ.

ASP.NET Core tự gắn token của request (HttpContext.RequestAborted) vào tham số CancellationToken của action. Việc của mình là truyền nó xuống tới tận cùng:

public async Task<Order?> GetOrderAsync(int id, CancellationToken ct)
{
    // EF Core và HttpClient đều nhận token, request bị huỷ thì query cũng dừng
    return await _db.Orders
        .AsNoTracking()
        .FirstOrDefaultAsync(o => o.Id == id, ct);
}

Method async nào gọi I/O thì nhận CancellationToken làm tham số cuối. Gõ thêm chừng chục ký tự mỗi hàm, không ai tính tiền.

Bọc Task.Run cho "nhanh hơn"

// Không nhanh hơn chút nào: vẫn tốn một thread khác của cùng thread pool
var report = await Task.Run(() => BuildReport(data));

Trong desktop app, Task.Run có ích vì nó đẩy việc nặng ra khỏi UI thread. Trong ASP.NET Core thì request vốn đã chạy trên thread pool rồi, Task.Run chỉ chuyển việc sang một thread khác cũng của pool đó, tốn thêm một lượt điều phối mà chẳng được gì. Còn bọc code sync gọi I/O vào Task.Run thì vẫn là một thread đứng chờ, chỉ là đổi thread khác đứng.

ConfigureAwait(false) khắp nơi

Đây là thói quen mang từ thời ASP.NET cũ. Trong code ứng dụng ASP.NET Core thì không cần, vì không có SynchronizationContext để mà tránh. Nếu bạn viết thư viện dùng chung cho cả app desktop thì vẫn nên giữ. Còn rải ConfigureAwait(false) khắp controller và service thì chỉ làm code rối hơn.

Bắt sớm từ lúc viết code

Mấy lỗi trên đều bắt được trước khi lên prod. Mình thêm package analyzer Microsoft.VisualStudio.Threading.Analyzers vào project. Nó cảnh báo khi gặp chỗ chặn chờ task (VSTHRD002) hay async void (VSTHRD100). Lần đầu bật lên, project của mình ra cả đống cảnh báo, đủ biết "chỉ một chữ .Result" thật ra không chỉ có một.

Ngoài ra, khi review PR, mình search nhanh mấy chuỗi .Result, .Wait(), GetAwaiter().GetResult(), async void. Mất mười giây mà đỡ được một buổi sáng như sáng hôm đó.


Nếu muốn thử ngay: chạy dotnet-counters monitor trên API của bạn lúc tải cao nhất trong ngày, nhìn hàng đợi của thread pool có dài ra không. Rồi search .Result trong solution, có khi bạn sẽ bất ngờ. Bài sau mình nói về một thứ gây sự cố cũng kiểu "lúc test không sao": HttpClient và chuyện hết socket.

Bạn đã từng dính thread pool starvation chưa, và lần ra nó bằng cách nào? Comment cho mình biết với.

P.S. Lần đó mình mất gần cả buổi sáng vì đoán trước khi đo. Giờ gặp sự cố kiểu này mình hay chạy skill debug trong PrimeKit, bộ skill mình tự làm. Skill bắt AI ghi rõ triệu chứng, tái hiện lỗi, rồi kiểm từng giả thuyết một; phần chẩn đoán hiệu năng của nó có đúng dòng "response time cao, CPU thấp" trỏ về blocking I/O, khớp y case này. Cài bằng npx @lovehlmmm/primekit init, rồi gõ /pk:debug trong Claude Code kèm triệu chứng và số liệu bạn đo được. Nó không tự nhìn được vào server prod của bạn, nên số từ dotnet-counters vẫn phải do bạn đưa vào.


All rights reserved

Viblo
Hãy đăng ký một tài khoản Viblo để nhận được nhiều bài viết thú vị hơn.
Đăng kí