async và await, đây là hai từ khóa chính để sử dụng trong lập trình bất đồng bộ. Lập trình bất đồng bộ [asynchronous] là một cách thức mà khi gọi nó chạy ở chế độ nền [liên quan đến một tiến trình, task], trong khi đó tiến trình gọi nó không bị khóa - block. Trong .NET có triển khai một số mô hình lập trình bất đồng bộ như Asynchronous pattern, mẫu bất đồng bộ theo sự kiện và theo tác vụ [TAP - task-based asynchronous pattern]
Phần này sẽ nói về TAP - task-based asynchronous pattern - mộ hình lập trình bất đồng bộ thông dụng trên .NET hiện nay.
Lập trình đồng bộ synchronous
Bình thường, khi lập trình gọi một phương thức nào đó thì phương thức đó chạy và kết thúc thì các dòng code tiếp theo sau lời gọi phương thức đó mới được thực thi, đó là chạy đồng bộ, có nghĩa là thread gọi phương thức bị khóa lại cho đến khi phương thức kết thúc.
Thử xem ví dụ đơn giản sau:
DownloadWebsite01.cs
using System;
using System.Net;
using System.Threading;
namespace CS021_ASYNCHRONOUS {
public class DownloadWebsite01 {
public static string DownloadWebpage [string url, bool showresult] {
using [var client = new WebClient []] {
Console.Write ["Starting download ..."];
string content = client.DownloadString [url];
Thread.Sleep [3000];
if [showresult]
Console.WriteLine [content.Substring [0, 150]];
return content;
}
}
public static void TestDownloadWebpage[]
{
string url = "//code.visualstudio.com/";
DownloadWebpage[url, true];
Console.WriteLine["Do somthing ..."];
}
}
}
Hãy gọi TestDownloadWebpage[] trong hàm main để kiểm tra.
Phương thức DownloadWebpage sử dụng lớp WebClient để tải về một trang web, trả về chuỗi nội dung trang.
Khi chạy, thì lời gọi DownloadWebpage[url, true];, phương thức này thi hành
xong thì dòng code Console.WriteLine["Do somthing ..."]; mới được thi hành.
Vấn đề là khi DownloadWebpage[url, true]; chạy, nó sẽ khóa thread gọi nó, làm cho các dòng code tiếp theo phải chờ, nếu hàm đó thi hành mất nhiều thời gian [đặc biệt là các thao tác đọc stream - đọc file, kết nối web, kết nối CSDL ...] - trong khi tài nguyên vẫn đủ để làm các việc khác - thì chương trình vẫn cứ phải chờ phương thức trên kết thúc thì mới thi hành được tác vụ khác - đặt biệt là khi gọi phương thức trong các tiến trình UI, giao diện người dùng
không tương tác được.
Để giải quyết vấn đề này, trong khi chờ cho DownloadWebpage[url, true] thi hành xong, chương trình vẫn thi hành được các tác vụ khác thì cần đến kỹ thuật lập trình bất đồng bộ [trước đây gọi là lập trình đa tiến trình, đa luồng]
Lớp Task
Lớp Task nó biểu thị tác vụ bất đồng bộ, từ đó ta chạy được code bất đồng bộ. Nếu tác vụ bất đồng bộ đó thi hành xong có kiểu trả về thì dùng Task với T là kiểu trả về.
Cần sử dụng các namespace sau để có thư viện về Task
using System.Threading; using System.Threading.Tasks;
Chú ý hãy tìm hiểu về hàm ủy quyền delegate C# trước
Cú pháp tạo ra đối tượng Task cơ bản
Để tạo ra một Task bạn cần tham số là một hàm delegate [ Func hoặc Action], ví dụ delegate có tên myfunc thì khởi tạo
Nếu myfunc trả về kiểu T [tức là một Func] thì khởi tạo
Task task = new Task[myfunc];
Nếu cần truyền tham số cho myfunc thì khởi tạo:
// object là đối tượng tham số truyền cho myfunc Task task = new Task[myfunc, object];
Nếu myfunc không trả về giá trị [tức là Action] thì khởi tạo:
// object là đối tượng tham số truyền cho myfunc Task task = new Task[myfunc];
Để chạy Task gọi phương thức Start[] của đối tượng được tạo ra. Nếu có kết quả trả về thì đọc kết quả tại thuộc tính Result, đề chờ cho task hoàn thành thì gọi Wait[]
Ta sẽ làm một ví dụ sử dụng Task tạo ra các 2 tiến trình con chạy đồng thời:
TestAsync01.cs
using System;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
namespace CS021_ASYNCHRONOUS {
public class TestAsync01 {
// Viết ra màn hình thông báo có màu
public static void WriteLine [string s, ConsoleColor color] {
Console.ForegroundColor = color;
Console.WriteLine [s];
}
// Tạo và chạy Task, sử dụng delegate Func [có kiểu trả về]
public static Task Async1 [string thamso1, string thamso2] {
// tạo biến delegate trả về kiểu string, có một tham số object
Func myfunc = [object thamso] => {
// Đọc tham số [dùng kiểu động - xem kiểu động để biết chi tiết]
dynamic ts = thamso;
for [int i = 1; i {
for [int i = 1; i {
// code ...
return ...;
};
Sau đó tạo Task với cú pháp
Task task = new Task[func, thamso];
Khi đã có Task, gọi phương thức Start[] của nó để bắt đầu chạy thread, một thread mới bất đồng bộ sẽ khởi chạy - nó sẽ không khóa thread gọi nó - các dòng code tiếp theo của thread chính vẫn chạy trong khi Task đang thi hành.
Khi
Task chạy xong, kết quả delegate trả về lưu ở thuộc tính Result [task.Result]
Kết quả chạy code trên, hai thread con đang chạy song song, trong khi thread chính đàng chờ người người dùng bấm bàn phím.
Cũng để ý Async2 ở trên lại dùng Task chứ không phải Task, áp dụng khi hàm bất đồng bộ không cần kết quả trả về, lúc đó lại dùng hàm delegate dạng Action chứ không dùng Func, cú pháp:
Action action = [] => {};
Task task = new Task[action];
async và await
Mã trên bạn thấy, khi đối tượng
Task khởi chạy bằng Start thì thread của Task chạy, và những dòng code sau Start[] được xử lý mà không bị khóa lại. Như đã nói trên, thread chạy - và khi delegate hoàn thành kết quả trả về lưu ở task.Result
Vấn đề là khi truy cập task.Result để đọc kết quả trả về, thì dòng code đó sẽ chờ cho Task hoàn thành để đọc dẫn đến dòng code sau đó không được thực thi - do thread gọi lại bị block, ví dụ cập nhật hàm Async1 để thấy rõ điều đó.
public static Task Async1 [string thamso1, string thamso2] {
// tạo biến delegate trả về kiểu string, có một tham số object
Func myfunc = [object thamso] => {
// Đọc tham số [dùng kiểu động - xem kiểu động để biết chi tiết]
dynamic ts = thamso;
for [int i = 1; i Lợi ích của đa luồng, bất đồng bộ mất đi.Giờ bạn mong muốn khi gọi Async1[], nó trả về ngay lập tức [nghĩa là không khóa thread gọi nó, mặc dù bắt đầu chạy một task] - trong khi bên trong Async1[] vẫn đảm bảo, có những đoạn code chỉ được thi hành khi task trong nó kết thúc [đoạn code phía sau string ketqua = task.Result;]
Lúc này bạn cần sử dụng đến cặp từ khóa
async và await. Tiến hành làm như sau:
Bước 1] Thêm vào khai báo tên hàm từ khóa async, nó cho trình biên dịch biết đây là hàm bất đồng bộ - khi gọi nó - nó trả về ngay lập tức
public static async Task Async1 [string thamso1, string thamso2]
Bước 2] Trong thân của Async1, phải có đoạn code chờ task hoàn thành
await task; // đây là điểm không khóa thread chính, thread chính chạy tiếp, task chạy tiếp
- Lời gọi hàm Async1 chuyển hướng về chỗ gọi nó khi gặp
await[tạm dừng thi hành mã sau await] - Code trong Async1 phía sau
awaitchỉ được chạy khitaskchạy xong - Khi
awaithoàn thành thì nó chứa kết quả của Task nếu có awaitchỉ viết được trong hàm có khai báoasync- Nhớ là
awaitphải dùng với Task
Với hàm async không cần kiểu trả về thì phải trả về Task tránh dùng void, xem code Async2 phía dưới.
Vậy hàm Async sau khi chuyển nó là hàm bất đồng bộ với từ khóa async và await sẽ như sau:
using System;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
namespace CS021_ASYNCHRONOUS {
public class TestAsyncAwait {
// Viết ra màn hình thông báo có màu
public static void WriteLine [string s, ConsoleColor color] {
Console.ForegroundColor = color;
Console.WriteLine [s];
}
// Tạo và chạy Task, sử dụng delegate Func [có kiểu trả về]
public static async Task Async1 [string thamso1, string thamso2] {
// tạo biến delegate trả về kiểu string, có một tham số object
Func myfunc = [object thamso] => {
// Đọc tham số [dùng kiểu động - xem kiểu động để biết chi tiết]
dynamic ts = thamso;
for [int i = 1; i {
for [int i = 1; i {
using [var client = new WebClient []] {
Console.Write ["Starting download ..." + url];
// mảng byte tải về
byte[] data = client.DownloadData[new Uri[url]];
// Lấy tên file để lưu
string filename = System.IO.Path.GetFileName[url];
System.IO.File.WriteAllBytes[filename, data];
}
};
Task task = new Task[downloadaction];
task.Start[];
await task;
Console.WriteLine["Đã hoàn thành tải file"];
}
}
}
Ta thấy toàn bố code của thân hàm khi ở trạng thái đồng bộ được đưa vào một Action [deleage] có tên downloadaction, sau đó tạo Task từ delegate này. Đồng thời biến đổi DownloadFile thành bất đồng bộ.
Hàm Main gọi tải thử
static async Task Main[string[] args]
{
string url = "//github.com/microsoft/vscode/archive/1.48.0.tar.gz";
var taskdonload = DownloadAsync.DownloadFile[url];
//..
Console.WriteLine["Làm gì đó khi file đang tải"];
//..
await taskdonload;
Console.WriteLine["Làm gì đó khi file tải xong"];
}
Hãy chạy thử để xem kết quả, nó tải về mã nguồn VSC từ github. Trong khi file đang tải ở thread chính làm việc gì đó tùy bạn
Yêu cầu kết thúc Task đang thực thi với CancellationToken
Khi tạo ra các Task, còn có thể khởi tạo - truyền cho nó một đối tượng kiểu CancellationToken, đối tượng này được phát sinh bởi lớp CancellationTokenSource. Khi trong task có CancellationToken thì trong quá trình thực thi nó có thể kiểm tra CancellationToken.IsCancellationRequested, nếu là true thì có yêu cầu dừng task, lúc này code trong task chủ động kết thúc task.
Ví dụ: có task1, task2 đang chạy, nếu nhấn phím e thì 2 task này kết thúc
static async Task Main[string[] args]
{
// Đối tượng để phát đi yêu cầu dừng Task
var tokenSource = new CancellationTokenSource[];
// Lấy token - để sử dụng bởi task, khi task thực thi
// token.IsCancellationRequested là true nếu có phát yêu cầu dừng
// bằng cách gọi tokenSource.Cancel
var token = tokenSource.Token;
// Tạo task1 có sử dụng CancellationToken
Task task1 = new Task[
[] => {
for [int i = 0; i < 10000; i++]
{
// Kiểm tra xem có yêu cầu dừng thì kết thúc task
if [token.IsCancellationRequested]
{
Console.WriteLine["TASK1 STOP"];
token.ThrowIfCancellationRequested[];
return;
}
// Chạy tiếp
Console.WriteLine["TASK1 runing ... " + i];
Thread.Sleep[300];
}
},
token
];
// Tạo task1 có sử dụng CancellationToken
Task task2 = new Task[
[] => {
for [int i = 0; i < 10000; i++]
{
if [token.IsCancellationRequested]
{
Console.WriteLine["TASK1 STOP"];
token.ThrowIfCancellationRequested[];
return;
}
Console.WriteLine["TASK2 runing ... " + i];
Thread.Sleep[300];
}
},
token
];
// Chạy các task
task1.Start[];
task2.Start[];
while [true]
{
var c = Console.ReadKey[].KeyChar;
// Nếu bấm e sẽ phát yêu cầu dừng task
if [c == 'e']
{
// phát yêu cầu dừng task
tokenSource.Cancel[];
break;
}
}
Console.WriteLine["Các task đã kết thúc, bấm phím bất kỳ kết thúc chương trình"];
Console.ReadKey[];
}
Lưu ý trong .NET hỗ trọng dừng task bằng cách dụng CancellationToken, nhưng không có sẵn các lớp hỗ trợ để PAUSE [tạm dừng] task đang chạy, cũng như RESUME [chạy tiếp] một task đang dừng. Nếu muốn có chức năng này bạn cần tự triển khai, hãy theo hướng dẫn tại pausing async methods để xây dựng ra các lớp PauseTokenSource, PauseToken
Mã nguồn ví dụ CS021_ASYNCHRONOUS [git] hoặc tải về ex021