Async/await
Ví dụ C#

Hàm C# bên dưới tải xuống tài nguyên từ URI và trả về độ dài của tài nguyên, sử dụng mô thức async/await như sau:
public async Task<int> FindPageSizeAsync(Uri uri) 
{
    byte[] data = await new HttpClient().GetByteArrayAsync(uri);
    return data.Length;
}
Đầu tiên, từ khóa async bảo cho C# rằng phương thức này là bất đồng bộ, nghĩa là phương thức này có thể sử dụng một số lượng tùy ý các biểu thức await và sẽ ràng buộc kết quả vào một promise nào đó.
Kiểu trả về, Task<T>, là cái tương tự của C# với với khái niệm promise, và ở đây bảo rằng kết quả của quá trình bất đồng bộ là kiểu int.
Khi phương thức này được gọi thì biểu thức đầu tiên là new HttpClient().GetByteArrayAsync(uri) của nó sẽ được thực thi, đấy là một phương thức bất đồng bộ khác trả về kiểu Task<byte[]>. Vì phương thức đấy là bất đồng bộ, nên nó sẽ không tải xuống hết phần dữ liệu rồi mới trả về. Mà thay vào đó, nó sẽ bắt đầu quá trình tải xuống bằng cơ chế non-blocking (chẳng hạn như thread chạy nền), rồi ngay lập tức trả về Task<byte[]> với trạng thái unresolved (chưa phân giải) và unrejected (chưa bị từ chối) cho hàm FindPageSizeAsync().
Với từ khóa await gắn vào Task đấy, FindPageSizeAsync() sẽ lập tức tiến hành trả về Task<int> cho caller của nó, rồi caller đó có thể tiếp tục   xử lý những gì đó khác nếu cần.
Một khi GetByteArrayAsync() hoàn tất việc tải xuống, nó sẽ phân giải Task mà nó đã trả về thành giá trị dữ liệu tải về. Điều này sẽ trigger một callback và khiến FindPageSizeAsync() tiếp tục thực thi bằng việc gán giá trị đó cho data.
Cuối cùng, phương thức này trả về data.Length, một số nguyên đơn giản cho biết độ dài của mảng. Trình biên dịch diễn giải lại việc này thành các bước là phân giải cái Task<int> mà nó trả về lúc trước rồi trigger callback trong caller của phương thức này để làm gì đó với giá trị độ dài vừa nêu.
Hàm mà sử dụng async/await thì có thể dùng bao nhiêu biểu thức await cũng được tùy ý muốn, và mỗi biểu thức như thế sẽ được xử trí theo cùng cách (thông qua một promise sẽ chỉ được trả về cho caller cho lần await đầu tiên, còn các lần await sau sẽ tận dụng callback nội bộ). Hàm cũng có thể tự tay giữ lại đối tượng promise và đi xử lý việc khác trước (bao gồm cả việc khởi động những tác vụ bất đồng bộ khác), trì hoãn việc await promise đấy cho đến khi nào cần đến kết quả của promise đấy thì mới thôi. Hàm mà dùng promise thì cũng có phương thức kết tập promise cho phép ta await nhiều promise cùng một lúc hay trong một số mô thức đặc biêt (chẳng hạn như Task.WhenAll() trong .NET có chức năng trả về một Task không có giá trị, nó phân giải khi tất cả tác vụ trong đối số của Task.WhenAll() được phân giải xong). Nhiều kiểu promise cũng có các tính năng vượt xa những điều mà mô thức async/await hay dùng, chẳng hạn có thể thiết đặt nhiều hơn một callback kết quả hay có thể tra duyệt tiến trình của tác vụ nào mà chạy lâu cá biệt.
Trong trường hợp đặc thù như C#, và trong nhiều ngôn ngữ có tính năng này, thì mô thức async/await không phải là một phần cốt lõi trong runtime của ngôn ngữ, mà thay vào đó được thực hiện bằng lambda hoặc được thực hiện bằng 'phần tiếp tục' tại compile time. Thí dụ, trình biên dịch C# khả năng sẽ dịch đoạn code bên trên thành thứ gì đó như sau đây trước khi dịch nó thành định dạng bytecode IL:
public Task<int> FindPageSizeAsync(Uri uri) 
{
    Task<byte[]> dataTask = new HttpClient().GetByteArrayAsync(uri);
    Task<int> afterDataTask = dataTask.ContinueWith((originalTask) => {
        return originalTask.Result.Length;
    });
    return afterDataTask;
}
Bởi vì điều này, nếu phương thức giao diện mà cần trả về đối tượng promise, nhưng bản thân nó lại không yêu cầu await trong phần thân để chờ đợi bất kì tác vụ bất đồng bộ nào, thì nó cũng chẳng cần đến từ khóa tu sức async và thay vào đó có thể trả về đối tượng promise trực tiếp luôn. Thí dụ, hàm có thể đưa ra một promise mà ngay lập tức phân giải thành giá trị kết quả nào đó (chẳng hạn như Task.FromResult() của C#), hoặc nó có thể đơn giản trả về một promise khác mà vô hình trung chính là promise cần.
Tuy nhiên có một điểm quan trọng cần lưu tâm của chức năng này, đó là mặc dù phần code trông giống như code blocking xưa giờ, thì thực ra bản chất nó là code non-blocking và còn có khả năng là đa thread nữa, nghĩa là nhiều sự kiện khác có thể xen vào trong khi chờ đợi promise được phân giải bằng await. Thí dụ, đoạn code sau, tuy luôn luôn chạy thành công nếu viết lại theo mô hình blocking mà không dùng await, nhưng theo đúng thế này thì lại có thể bị các sự kiện bên ngoài can thiệp vào trong quá trình await và do đó có thể xảy ra tình cảnh nội dung trong state chung bị thay đổi khi code chạy đến phần bên dưới await.
var a = state.a;
var data = await new HttpClient().GetByteArrayAsync(uri);
Debug.Assert(a == state.a); // Có khả năng là không được vì giá trị của state.a
                            // có thể đã bị handler của sự kiện xen giữa nào đó thay đổi rồi.
return data.Length;