1 介绍
协程是比线程更加轻量级并发编程方式，CPU资源在用户态进行切换,CPU切换信息在用户态保存。
协程完成异步的调用流程，并对用户展示出同步的使用方式。
协程的调度由应用层决定，所以不同的实现会有不同的调度方式，调度策略比较灵活。
协程是基于线程之上运行，同一个线程中，协程是串行的，不会产生线程资源的竞争，不同的协程间却是相互交叉运行的，只要依赖的线程没有终止，协程最终会跳转回来。
协程可以充分利用单核CPU的资源，但是不太好利用多核CPU资源。
c++20 协程使用三大关键字 co_wait,co_return,co_yield
在函数中使用到以上关键字的函数被称为协程函数，并且通过该关键字完成跳转。
2 使用
如果要使用协程函数，需要定义promise_type以及基本成员函数实现。
包括get_return_object、initial_suspend、final_suspend、unhandled_exception。
演示代码最下面展示
co_return 执行完协程函数并返回结果
需要额外定义return_void函数。
流程分析：
1 可以看出调用co_return跳转到return_void，return_void执行完后，main函数向下执行。
2 "co_test1 end"并没有打印，说明协程函数co_test1分割开来，通过co_return切换了CPU资源，使主线程继续执行。
co_await 执行到异步操作处，判断并进行挂起操作。
使用co_await 还需要再定义xxxx类并实现await_ready、await_suspend、await_resume函数。
1 协程函数中调用co_await后，跳转xxx的await_ready并判断是否就绪，如果是true，则协程函数调回继续运行，反之进入await_suspend挂起，协程函数跳出，直到调用await_resume后再次跳入协程函数执行余下操作。
2 可以看到在“co_test2 result”打印之前，main函数已执行完成，等到await_resume后依然会跳回协程函数并执行余下部分。
co_yield 让出操作
需要额外定义yield_value函数。
1 执行co_yield 会跳转到yield_value函数中，通过resume以及promise操作获取结果。
3 代码用例
以下代码在linux下测试，gcc版本需要 linux-gcc10.1以上。
编译指令：g++ faw.cpp -fcoroutines -std=c++20
#include <iostream>
#include <coroutine>
#include <thread>
#include <functional>
#include <chrono>
template <typename... Args>
void print_log(const char* fmt, Args... args) {
char log_buf[128] = { 0 };
snprintf(log_buf, 128, fmt, args...);
char time_buf[64] = { 0 };
unsigned long tid = pthread_self();
char buf[160] = { 0 };
snprintf(buf, 160, "[%lu] [%s]", tid, log_buf);
std::cout << buf << std::endl;
}
using callback_t = std::function<void(int)>;
void async_op(int value, callback_t cb) {
std::thread t([value, cb]() {
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
cb(value+1000);
});
t.detach();
}
struct MyTask {
struct promise_type;
using handle_t = std::coroutine_handle<promise_type>; //yield操作
MyTask() {
}
MyTask(handle_t handle)
: handle_(handle) {
}
struct promise_type {
MyTask get_return_object() {
print_log("get_return_object beg");
return MyTask(handle_t::from_promise(*this));
}
std::suspend_never initial_suspend() {
print_log("initial_suspend beg");
return std::suspend_never();
}
std::suspend_never final_suspend() noexcept {
print_log("final_suspend beg");
return std::suspend_never();
}
//co_return
void return_void() {
print_log("return_void beg");
std::this_thread::sleep_for(std::chrono::milliseconds(1000)); //测试异步
}
void unhandled_exception() {}
//co_yield
auto yield_value(int v) {
data_ = v;
return std::suspend_always();
}
int data_ = 0;
};
int get_value() {
handle_.resume();
if(!handle_.done()){
return handle_.promise().data_;
}
return -1;
}
handle_t handle_;
};
//co_await操作
class AwaitOp {
public:
AwaitOp(int value)
: input_(value), result_(0) {}
bool await_ready() {
print_log("await_ready beg");
std::this_thread::sleep_for(std::chrono::milliseconds(1000)); //测试阻塞情况
return false;
}
void await_suspend(std::coroutine_handle<> handle) {
auto cb = [handle, this](int value) mutable {
result_ = value;
print_log("----------");
handle.resume(); //执行完后调回
};
async_op(input_, cb);
}
int await_resume() {
print_log("await_resume beg");
return result_;
}
private:
int input_;;
int result_;
};
#if 1
MyTask co_test1(){
print_log("co_test1 beg");
co_return; //业务跳转，协程函数退出
print_log("co_test1 end");
}
MyTask co_test2(){
print_log("co_test2 beg");
int input= 999;
int result = co_await AwaitOp(input); //业务跳转，协程函数退出
print_log("co_test2 result=%d",result);
co_return;
print_log("co_test2 end");
}
#endif
MyTask co_test3_2(){
print_log("co_test3_2 beg");
int t = 99;
co_yield t; //切换出去
print_log("co_test3_2 end");
}
void co_test3(){
MyTask task = co_test3_2();
int result = task.get_value(); //切换结果
print_log("co_test3 result=%d",result);
}
int main() {
print_log("main beg");
co_test1(); //co_return测试
//co_test2(); //co_await测试
//co_test3(); //co_yield测试
print_log("main end");
getchar();
return 0;
}
