Ở cấp độ trừu tượng, Coroutines tách ý tưởng có một trạng thái thực thi ra khỏi ý tưởng có một chuỗi thực thi.
SIMD (một lệnh nhiều dữ liệu) có nhiều "luồng thực thi" nhưng chỉ có một trạng thái thực thi (nó chỉ hoạt động trên nhiều dữ liệu). Các thuật toán song song có thể cho là giống như thế này, trong đó bạn có một "chương trình" chạy trên các dữ liệu khác nhau.
Phân luồng có nhiều "luồng thực thi" và nhiều trạng thái thực thi. Bạn có nhiều chương trình và nhiều luồng thực thi.
Coroutines có nhiều trạng thái thực thi, nhưng không sở hữu một chuỗi thực thi. Bạn có một chương trình, và chương trình có trạng thái, nhưng nó không có luồng thực thi.
Ví dụ đơn giản nhất về coroutines là trình tạo hoặc liệt kê từ các ngôn ngữ khác.
Trong mã giả:
function Generator() {
for (i = 0 to 100)
produce i
}
Các Generatorđược gọi, và lần đầu tiên nó được gọi là nó trả về 0. Trạng thái của nó được ghi nhớ (mức độ thay đổi trạng thái tùy theo việc triển khai các coroutines), và lần sau khi bạn gọi nó, nó sẽ tiếp tục ở vị trí đã dừng. Vì vậy, nó trả về 1 trong lần tiếp theo. Sau đó 2.
Cuối cùng nó đến cuối vòng lặp và rơi ra khỏi phần cuối của hàm; quy trình đăng quang đã kết thúc. (Những gì xảy ra ở đây thay đổi tùy theo ngôn ngữ mà chúng ta đang nói đến; trong python, nó đưa ra một ngoại lệ).
Coroutines mang lại khả năng này cho C ++.
Có hai loại coroutines; xếp chồng lên nhau và không xếp chồng lên nhau.
Một chương trình điều chỉnh không ngăn xếp chỉ lưu trữ các biến cục bộ ở trạng thái và vị trí thực thi của nó.
Một chương trình điều chỉnh nhiều ngăn xếp lưu trữ toàn bộ một ngăn xếp (giống như một chuỗi).
Các coroutines không chồng chất có thể có trọng lượng cực kỳ nhẹ. Đề xuất cuối cùng tôi đọc về cơ bản liên quan đến việc viết lại hàm của bạn thành một thứ giống như lambda; tất cả các biến cục bộ đều chuyển sang trạng thái của một đối tượng và các nhãn được sử dụng để chuyển đến / từ vị trí mà coroutine "tạo ra" các kết quả trung gian.
Quá trình tạo ra một giá trị được gọi là "sản lượng", vì các coroutines giống như đa luồng hợp tác; bạn đang nhường điểm thực thi lại cho người gọi.
Boost có một triển khai các coroutines xếp chồng lên nhau; nó cho phép bạn gọi một hàm để nhường cho bạn. Các coroutines xếp chồng lên nhau mạnh hơn nhưng cũng đắt hơn.
Có nhiều điều để điều tra hơn một máy phát điện đơn giản. Bạn có thể chờ một quy trình đăng ký trong một quy trình đăng ký, điều này cho phép bạn soạn các quy trình đăng ký một cách hữu ích.
Coroutines, như if, vòng lặp và lệnh gọi hàm, là một loại "goto có cấu trúc" khác cho phép bạn diễn đạt các mẫu hữu ích nhất định (như máy trạng thái) theo cách tự nhiên hơn.
Việc triển khai cụ thể của Coroutines trong C ++ có một chút thú vị.
Ở cấp độ cơ bản nhất, nó thêm một số từ khóa vào C ++:, co_return co_await co_yieldcùng với một số kiểu thư viện hoạt động với chúng.
Một hàm trở thành một quy trình bằng cách có một trong những hàm đó trong cơ thể của nó. Vì vậy, từ khai báo của họ, họ không thể phân biệt được với các hàm.
Khi một trong ba từ khóa đó được sử dụng trong thân hàm, một số kiểm tra bắt buộc tiêu chuẩn về kiểu trả về và các đối số sẽ xảy ra và hàm được chuyển thành một chương trình đăng quang. Việc kiểm tra này cho trình biên dịch biết nơi lưu trữ trạng thái chức năng khi chức năng bị tạm dừng.
Quy trình đăng quang đơn giản nhất là một trình tạo:
generator<int> get_integers( int start=0, int step=1 ) {
for (int current=start; true; current+= step)
co_yield current;
}
co_yieldtạm dừng việc thực thi các hàm, lưu trữ trạng thái đó trong generator<int>, sau đó trả về giá trị của currentqua generator<int>.
Bạn có thể lặp lại các số nguyên được trả về.
co_awaittrong khi đó cho phép bạn ghép một quy trình điều tra này vào một quy trình khác. Nếu bạn đang tham gia một chương trình đăng quang và bạn cần kết quả của một việc có thể chờ đợi được (thường là một quy trình đăng quang) trước khi tiến hành, bạn co_awaitphải làm như vậy. Nếu họ đã sẵn sàng, bạn tiến hành ngay lập tức; nếu không, bạn tạm ngưng cho đến khi sẵn sàng.
std::future<std::expected<std::string>> load_data( std::string resource )
{
auto handle = co_await open_resouce(resource);
while( auto line = co_await read_line(handle)) {
if (std::optional<std::string> r = parse_data_from_line( line ))
co_return *r;
}
co_return std::unexpected( resource_lacks_data(resource) );
}
load_datalà một chương trình điều tra tạo ra std::futurekhi tài nguyên được đặt tên được mở và chúng tôi quản lý để phân tích cú pháp đến điểm mà chúng tôi tìm thấy dữ liệu được yêu cầu.
open_resourcevà read_lines có thể là các coroutines không đồng bộ để mở một tệp và đọc các dòng từ nó. Kết co_awaitnối trạng thái tạm ngừng và sẵn sàng load_datavới tiến trình của chúng.
C ++ coroutines linh hoạt hơn nhiều so với điều này, vì chúng được triển khai dưới dạng một tập hợp tối thiểu các tính năng ngôn ngữ trên các loại không gian người dùng. Các kiểu không gian người dùng xác định hiệu quả điều gì co_return co_awaitvà co_yield ý nghĩa - Tôi đã thấy mọi người sử dụng nó để triển khai các biểu thức tùy chọn đơn nguyên sao cho một co_awaittrên tùy chọn trống tự động đề xuất trạng thái trống cho tùy chọn bên ngoài:
modified_optional<int> add( modified_optional<int> a, modified_optional<int> b ) {
return (co_await a) + (co_await b);
}
thay vì
std::optional<int> add( std::optional<int> a, std::optional<int> b ) {
if (!a) return std::nullopt;
if (!b) return std::nullopt;
return *a + *b;
}
