async await trong C#: Task, Task<T>, WhenAll và lỗi hay gặp

Hầu hết các thao tác chậm trong một chương trình thực chất là chờ đợi: chờ máy chủ web trả lời, chờ cơ sở dữ liệu trả về các hàng, chờ đọc xong một tệp. async và await cho phép một phương thức tạm dừng trong lúc chờ như vậy mà không giữ chân một thread nào, rồi tiếp tục từ chỗ đã dừng. Code vẫn đọc từ trên xuống dưới như code bình thường.

Phương thức async đầu tiên

Một phương thức async trả về Task (không có kết quả) hoặc Task<T> (kết quả kiểu T). Bên trong nó, await chờ một task khác và đưa bạn kết quả của task đó.

using System;
using System.Threading.Tasks;

class Program
{
    static async Task<decimal> GetPriceAsync(string product)
    {
        await Task.Delay(200);          // stands in for a network call
        return product == "tea" ? 2.50m : 4.00m;
    }

    static async Task RunAsync()
    {
        decimal tea = await GetPriceAsync("tea");
        decimal cake = await GetPriceAsync("cake");
        Console.WriteLine("Tea " + tea + ", cake " + cake + ", total " + (tea + cake));
    }

    static void Main()
    {
        RunAsync().GetAwaiter().GetResult();
    }
}

Đầu ra:

Tea 2.50, cake 4.00, total 6.50

GetPriceAsync viết return 2.50m, và trình biên dịch bọc giá trị đó vào Task<decimal> mà phương thức trả về. await lại mở gói nó ra. Task.Delay là phiên bản async của Thread.Sleep: nó hoàn thành khi hết thời gian, mà không chặn thread nào trong lúc chờ.

Từ C# 7.1, chính Main cũng có thể là async, và đó là cách bạn viết chương trình này trong .NET hiện đại:

static async Task Main()
{
    decimal tea = await GetPriceAsync("tea");
    Console.WriteLine(tea);
}

Các ví dụ chạy được trong trang này gọi phương thức async RunAsync từ một Main bình thường bằng .GetAwaiter().GetResult(), cũng chính là code mà trình biên dịch sinh ra cho một Main async. Trong ứng dụng console, cách này an toàn; phần nói về deadlock sẽ giải thích vì sao cùng lời gọi đó lại nguy hiểm trong code giao diện.

Điều gì xảy ra tại một await

Một phương thức async chạy đồng bộ cho đến await đầu tiên trên một task chưa hoàn thành. Tại điểm đó, nó trả về một Task cho bên gọi, và phần còn lại của phương thức trở thành một continuation, sẽ chạy khi task đang chờ hoàn thành.

using System;
using System.Threading.Tasks;

class Program
{
    static async Task DownloadAsync()
    {
        Console.WriteLine("  Download: starting");
        await Task.Delay(300);
        Console.WriteLine("  Download: finished");
    }

    static async Task RunAsync()
    {
        Console.WriteLine("Calling DownloadAsync");
        Task download = DownloadAsync();          // runs until its first await
        Console.WriteLine("DownloadAsync returned a task; doing other work");
        await download;                           // now wait for it
        Console.WriteLine("Download awaited");
    }

    static void Main()
    {
        RunAsync().GetAwaiter().GetResult();
    }
}

Đầu ra:

Calling DownloadAsync
  Download: starting
DownloadAsync returned a task; doing other work
  Download: finished
Download awaited

"Download: starting" được in ra trước khi DownloadAsync trả về, vì mọi thứ trước await đầu tiên đều chạy trên thread của bên gọi. Sau đó phương thức trả về một task chưa xong, bên gọi tiếp tục chạy, và "Download: finished" chỉ xuất hiện khi hết thời gian delay. Gọi một phương thức async là khởi động nó; await nó là cách bạn chờ kết quả.

async không tạo ra thread mới. Trong lúc phương thức tạm dừng, không có thread nào đứng chờ nó cả, vì vậy một máy chủ có thể có hàng nghìn request đang chờ cơ sở dữ liệu mà chỉ cần vài thread. Với công việc nặng về CPU cần chạy trên thread khác, hãy dùng Task.Run, được trình bày trong trang task.

Chạy đồng thời các thao tác với Task.WhenAll

Await từng lời gọi một là chạy tuần tự: mỗi lời gọi chỉ bắt đầu sau khi lời gọi trước đã xong. Khi các thao tác không phụ thuộc vào nhau, hãy khởi động tất cả rồi chờ chúng cùng nhau bằng Task.WhenAll:

using System;
using System.Diagnostics;
using System.Threading.Tasks;

class Program
{
    static async Task<int> FetchStockAsync(string item, int ms)
    {
        await Task.Delay(ms);   // simulated request
        return item.Length * 10;
    }

    static async Task RunAsync()
    {
        var sw = Stopwatch.StartNew();
        int a = await FetchStockAsync("apples", 300);
        int b = await FetchStockAsync("pears", 300);
        int c = await FetchStockAsync("plums", 300);
        Console.WriteLine("Sequential: " + (a + b + c) + " units in ~" + sw.ElapsedMilliseconds / 100 * 100 + " ms");

        sw.Restart();
        Task<int> ta = FetchStockAsync("apples", 300);   // all three start now
        Task<int> tb = FetchStockAsync("pears", 300);
        Task<int> tc = FetchStockAsync("plums", 300);
        int[] results = await Task.WhenAll(ta, tb, tc);
        Console.WriteLine("Concurrent: " + (results[0] + results[1] + results[2]) + " units in ~" + sw.ElapsedMilliseconds / 100 * 100 + " ms");
    }

    static void Main()
    {
        RunAsync().GetAwaiter().GetResult();
    }
}

Đầu ra mẫu:

Sequential: 160 units in ~900 ms
Concurrent: 160 units in ~300 ms

Phiên bản tuần tự mất tổng thời gian của cả ba lần chờ, còn phiên bản đồng thời chỉ mất khoảng thời gian của thao tác chậm nhất. Task.WhenAll trả về kết quả theo đúng thứ tự các task bạn truyền vào, bất kể task nào xong trước. Nó cũng dùng được với một danh sách, đây là dạng thường gặp khi cần "lấy từng mục": await Task.WhenAll(ids.Select(id => FetchAsync(id))).

Task.WhenAny là phương thức tương ứng, hoàn thành ngay khi task đầu tiên xong, hữu ích cho timeout và kiểu "câu trả lời đầu tiên thắng".

Ngoại lệ trong code async

Một ngoại lệ (exception) ném ra bên trong phương thức async được lưu trong task trả về và được ném lại khi task đó được await, nên một khối try/catch bình thường quanh await vẫn hoạt động:

using System;
using System.Threading.Tasks;

class Program
{
    static async Task<string> LoadProfileAsync(int userId)
    {
        await Task.Delay(50);
        if (userId <= 0) throw new ArgumentOutOfRangeException(nameof(userId));
        return "profile " + userId;
    }

    static async Task RunAsync()
    {
        Task<string> task = LoadProfileAsync(-1);   // no exception yet
        Console.WriteLine("Task created, completed yet: " + task.IsCompleted);

        try
        {
            await task;                              // rethrown here
        }
        catch (ArgumentOutOfRangeException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name + " for " + e.ParamName);
        }

        Task<string> ok = LoadProfileAsync(7);
        Task<string> bad = LoadProfileAsync(0);
        Task<string[]> all = Task.WhenAll(ok, bad);
        try
        {
            await all;
        }
        catch (ArgumentOutOfRangeException)
        {
            Console.WriteLine("WhenAll rethrew the first failure");
            Console.WriteLine("All failures: " + all.Exception.InnerExceptions.Count);
            Console.WriteLine("The other task still succeeded: " + ok.Result);
        }
    }

    static void Main()
    {
        RunAsync().GetAwaiter().GetResult();
    }
}

Đầu ra:

Task created, completed yet: False
Caught ArgumentOutOfRangeException for userId
WhenAll rethrew the first failure
All failures: 1
The other task still succeeded: profile 7

Lời gọi LoadProfileAsync(-1) không ném ngoại lệ: ngoại lệ nằm trong task cho đến khi có thứ gì đó await nó. Một task không bao giờ được await sẽ giấu hoàn toàn ngoại lệ của nó, thêm một lý do để luôn await những gì bạn khởi động. Với WhenAll, await ném lại ngoại lệ đầu tiên, còn thuộc tính Exception của task tổng hợp (một AggregateException) chứa tất cả. Đọc ok.Result ở đó không sao vì ok đã hoàn thành.

async void: chỉ dành cho event handler

Một phương thức async cũng có thể trả về void. Hãy tránh cách này ở mọi nơi trừ event handler:

// Bad: the caller cannot await it or catch its exceptions.
static async void SaveAsync(Order order)
{
    await db.InsertAsync(order);   // if this throws, the process may crash
}

// Good: return Task, so callers can await and handle errors.
static async Task SaveAsync(Order order)
{
    await db.InsertAsync(order);
}

// Acceptable: an event handler must return void.
private async void SaveButton_Click(object sender, EventArgs e)
{
    try { await SaveAsync(currentOrder); }
    catch (Exception ex) { ShowError(ex); }
}

Với async void, không có task nào để await, nên bên gọi chạy tiếp trước khi công việc xong, và ngoại lệ ném ra bên trong được ném thẳng lên synchronization context (hoặc thread pool), nơi không khối try/catch nào của bên gọi chạm tới được. Trong ứng dụng console hay máy chủ, điều này thường làm dừng tiến trình. Bên trong một event handler async void, hãy tự bắt mọi ngoại lệ.

Một lỗi liên quan là gọi phương thức async mà không có await. Trình biên dịch sẽ cảnh báo (CS4014), và phương thức chạy ngầm mà không ai theo dõi kết quả hay lỗi của nó.

Deadlock do .Result và .Wait()

Chặn một task bằng .Result hoặc .Wait() là chỗ code async hay hỏng nhất. Trong ứng dụng có synchronization context (WinForms, WPF, MAUI, ASP.NET cổ điển), trình tự diễn ra như sau:

1. Thread giao diện gọi GetDataAsync().Result và bị chặn, chờ task.
2. Bên trong GetDataAsync, một await hoàn thành. Mặc định, continuation của nó phải chạy trên context nơi nó bắt đầu: thread giao diện.
3. Thread giao diện đang bị chặn ở bước 1, nên continuation không bao giờ chạy, nên task không bao giờ hoàn thành, nên bước 1 không bao giờ kết thúc.

Ứng dụng bị đơ mà không có ngoại lệ nào. Ứng dụng console và ASP.NET Core không có context như vậy, đó là lý do cùng một đoạn code chạy được trong chương trình thử nhưng lại treo trong ứng dụng desktop. Cách khắc phục:

• Dùng await xuyên suốt chuỗi lời gọi thay vì chặn ("async từ đầu đến cuối"). Event handler có thể là async void cho mục đích này.
• Trong code thư viện không cần quay về context của bên gọi, hãy viết await SomethingAsync().ConfigureAwait(false);. Khi đó continuation chạy trên thread pool thay vì context đã lưu, và thư viện bỏ qua được một lần chuyển thread không cần thiết. Cách này chỉ bảo vệ được bên gọi đang chặn nếu mọi await trong chuỗi đều làm như vậy, nên hãy coi nó là thói quen tốt khi viết thư viện, không phải cách chữa cho .Result.

Code ứng dụng trong ASP.NET Core không cần ConfigureAwait(false), vì không có context nào để quay về.

Lỗi thường gặp

• Await từng lời gọi độc lập một. Hãy khởi động chúng, rồi await Task.WhenAll(...).
• Phương thức async void. Hãy trả về Task; chỉ dùng async void cho event handler.
• .Result và .Wait() trong code giao diện hoặc ASP.NET cổ điển. Chúng gây deadlock; hãy dùng await.
• Quên await. Công việc chạy mà không ai theo dõi và ngoại lệ của nó biến mất.
• Bọc thao tác I/O trong Task.Run. Một API async như File.ReadAllTextAsync hay HttpClient.GetStringAsync vốn đã giải phóng thread; Task.Run chỉ thêm một bước nhảy sang thread pool.
• Nghĩ rằng async nghĩa là "chạy trên thread khác". Nó có nghĩa là "có thể tạm dừng mà không chặn". Hãy dùng Task.Run cho công việc nặng về CPU.