C++20 协程——你还只是听过？觉得没时间了解，这里可以帮到你。五分钟 从没听过到使用的帮助手册

#include <coroutine>
#include <functional>
class Coroutine {
public:
    Coroutine(std::function<void()> func) : m_func(func) {}
    void start() {
        m_handle = std::coroutine_handle::from_promise(m_promise.get_return_object());
        m_handle.resume();
    }
    void resume() {
        m_handle.resume();
    }
    void stop() {
        m_handle.destroy();
    }
private:
    struct promise_type {
        auto get_return_object() {
            return std::coroutine_handle<promise_type>::from_promise(*this);
        }
        auto initial_suspend() {
            return std::suspend_never{};
        }
        auto final_suspend() noexcept {
            return std::suspend_never{};
        }
        void unhandled_exception() {
            std::terminate();
        }
    };
    std::function<void()> m_func;
    std::coroutine_handle<promise_type> m_handle;
    std::promise<void> m_promise;
};

#include <iostream>
void print_numbers(int start, int end) {
    for (int i = start; i <= end; i++) {
        std::cout << i << std::endl;
        co_yield;
    }
}
int main() {
    Coroutine c1([&]() { print_numbers(1, 5); });
    Coroutine c2([&]() { print_numbers(6, 10); });
    c1.start();
    c2.start();
    while (c1 || c2) {
        if (c1) {
            c1.resume();
        }
        if (c2) {
            c2.resume();
        }
    }
    return 0;
}

co_await表达式 — 暂停执行，直到恢复
task<> tcp_echo_server()
{
    char data[1024];
    while (true)
    {
        [std::size_t](https://en.cppreference.com/w/cpp/types/size_t) n = co_await socket.async_read_some(buffer(data));
        co_await async_write(socket, buffer(data, n));
    }
}

co_yield表达式 — 暂停执行返回值
generator<int> iota(int n = 0)
{
    while (true)
        co_yield n++;
}

co_return语句 — 完成返回值的执行
lazy<int> f()
{
    co_return 7;
}

#include <coroutine>
#include <iostream>
struct promise;
struct coroutine : std::coroutine_handle<promise>
{
    using promise_type = ::promise;
};
struct promise
{
    coroutine get_return_object() { return {coroutine::from_promise(*this)}; }
    std::suspend_always initial_suspend() noexcept { return {}; }
    std::suspend_always final_suspend() noexcept { return {}; }
    void return_void() {}
    void unhandled_exception() {}
};
struct S
{
    int i;
    coroutine f()
    {
        std::cout << i;
        co_return;
    }
};
void bad1()
{
    coroutine h = S{0}.f();
    // S{0} destroyed
    h.resume(); // resumed coroutine executes std::cout << i, uses S::i after free
    h.destroy();
}
coroutine bad2()
{
    S s{0};
    return s.f(); // returned coroutine can't be resumed without committing use after free
}
void bad3()
{
    coroutine h = [i = 0]() -> coroutine // a lambda that's also a coroutine
    {
        std::cout << i;
        co_return;
    }(); // immediately invoked
    // lambda destroyed
    h.resume(); // uses (anonymous lambda type)::i after free
    h.destroy();
}
void good()
{
    coroutine h = [](int i) -> coroutine // make i a coroutine parameter
    {
        std::cout << i;
        co_return;
    }(0);
    // lambda destroyed
    h.resume(); // no problem, i has been copied to the coroutine
                // frame as a by-value parameter
    h.destroy();
}

struct Coroutine::promise_type
{
    /* ... */
    // ensure the use of non-throwing operator-new
    static Coroutine get_return_object_on_allocation_failure()
    {
        std::cerr << "get_return_object_on_allocation_failure()\n";
        throw std::bad_alloc(); // or, return Coroutine(nullptr);
    }
    // custom non-throwing overload of new
    void* operator new(std::size_t n) noexcept
    {
        if (void* mem = std::malloc(n))
            return mem;
        return nullptr; // allocation failure
    }
};

#include <coroutine>
#include <iostream>
#include <stdexcept>
#include <thread>
auto switch_to_new_thread(std::jthread& out)
{
    struct awaitable
    {
        std::jthread* p_out;
        bool await_ready() { return false; }
        void await_suspend(std::coroutine_handle<> h)
        {
            std::jthread& out = *p_out;
            if (out.joinable())
                throw std::runtime_error("Output jthread parameter not empty");
            out = std::jthread([h] { h.resume(); });
            // Potential undefined behavior: accessing potentially destroyed *this
            // std::cout << "New thread ID: " << p_out->get_id() << '\n';
            std::cout << "New thread ID: " << out.get_id() << '\n'; // this is OK
        }
        void await_resume() {}
    };
    return awaitable{&out};
}
struct task
{
    struct promise_type
    {
        task get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };
};
task resuming_on_new_thread(std::jthread& out)
{
    std::cout << "Coroutine started on thread: " << std::this_thread::get_id() << '\n';
    co_await switch_to_new_thread(out);
    // awaiter destroyed here
    std::cout << "Coroutine resumed on thread: " << std::this_thread::get_id() << '\n';
}
int main()
{
    std::jthread out;
    resuming_on_new_thread(out);
}

Coroutine started on thread: 139972277602112
New thread ID: 139972267284224
Coroutine resumed on thread: 139972267284224

#include <coroutine>
#include <cstdint>
#include <exception>
#include <iostream>
template <typename T>
struct Generator
{
    // The class name 'Generator' is our choice and it is not required for coroutine
    // magic. Compiler recognizes coroutine by the presence of 'co_yield' keyword.
    // You can use name 'MyGenerator' (or any other name) instead as long as you include
    // nested struct promise_type with 'MyGenerator get_return_object()' method.
    struct promise_type;
    using handle_type = std::coroutine_handle<promise_type>;
    struct promise_type // required
    {
        T value_;
        std::exception_ptr exception_;
        Generator get_return_object()
        {
            return Generator(handle_type::from_promise(*this));
        }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void unhandled_exception() { exception_ = std::current_exception(); } // saving
                                                                              // exception
        template <std::convertible_to<T> From> // C++20 concept
        std::suspend_always yield_value(From&& from)
        {
            value_ = std::forward<From>(from); // caching the result in promise
            return {};
        }
        void return_void() { }
    };
    handle_type h_;
    Generator(handle_type h)
        : h_(h)
    {
    }
    ~Generator() { h_.destroy(); }
    explicit operator bool()
    {
        fill(); // The only way to reliably find out whether or not we finished coroutine,
                // whether or not there is going to be a next value generated (co_yield)
                // in coroutine via C++ getter (operator () below) is to execute/resume
                // coroutine until the next co_yield point (or let it fall off end).
                // Then we store/cache result in promise to allow getter (operator() below
                // to grab it without executing coroutine).
        return !h_.done();
    }
    T operator()()
    {
        fill();
        full_ = false; // we are going to move out previously cached
                       // result to make promise empty again
        return std::move(h_.promise().value_);
    }
private:
    bool full_ = false;
    void fill()
    {
        if (!full_)
        {
            h_();
            if (h_.promise().exception_)
                std::rethrow_exception(h_.promise().exception_);
            // propagate coroutine exception in called context
            full_ = true;
        }
    }
};
Generator<std::uint64_t>
fibonacci_sequence(unsigned n)
{
    if (n == 0)
        co_return;
    if (n > 94)
        throw std::runtime_error("Too big Fibonacci sequence. Elements would overflow.");
    co_yield 0;
    if (n == 1)
        co_return;
    co_yield 1;
    if (n == 2)
        co_return;
    std::uint64_t a = 0;
    std::uint64_t b = 1;
    for (unsigned i = 2; i < n; i++)
    {
        std::uint64_t s = a + b;
        co_yield s;
        a = b;
        b = s;
    }
}
int main()
{
    try
    {
        auto gen = fibonacci_sequence(10); // max 94 before uint64_t overflows
        for (int j = 0; gen; j++)
            std::cout << "fib(" << j << ")=" << gen() << '\n';
    }
    catch (const std::exception& ex)
    {
        std::cerr << "Exception: " << ex.what() << '\n';
    }
    catch (...)
    {
        std::cerr << "Unknown exception.\n";
    }
}

fib(0)=0
fib(1)=1
fib(2)=1
fib(3)=2
fib(4)=3
fib(5)=5
fib(6)=8
fib(7)=13
fib(8)=21
fib(9)=34

sudo yum install epel-release

sudo yum install centos-release-scl
sudo yum install devtoolset-10

scl enable devtoolset-10 bash

gcc --version

scl disable devtoolset-10

/*
 * @Author       : Zry && 978524088@qq.com
 * @Date         : 2023-06-13 18:09:34
 * @LastEditors  : Zry && 978524088@qq.com
 * @LastEditTime : 2023-06-13 18:21:55
 * @FilePath     : /zryTest/src/include/Mysql/coroutine.cpp
 * @Description  : 
 * 
 * Copyright (c) 2023 by 978524088@qq.com, All Rights Reserved. 
 */
#include <coroutine>
#include <iostream>
using namespace std;
struct CoRet
{
    struct promise_type
    {
        int _out;
        int _res;
        suspend_never initial_suspend() { return {}; }
        suspend_always final_suspend() noexcept { return {}; }
        void unhandled_exception() {}
        CoRet get_return_object()
        {
            return {coroutine_handle<promise_type>::from_promise(*this)};
        }
        suspend_always yield_value(int r)
        {
            _out = r;
            return {};
        }
        void return_value(int r) { _res = r; }
    };
    coroutine_handle<promise_type> _h; // _h.resume(), _h()
};
struct Note
{
    int guess;
};
struct Input
{
    Note &_in;
    bool await_ready() { return false; }
    void await_suspend(coroutine_handle<CoRet::promise_type> h) {}
    int await_resume() { return _in.guess; }
};
CoRet Guess(Note &note)
{
    // CoRet::promise_type promise;
    // CoRet ret = promise.get_return_object();
    // co_await promise.initial_suspend();
    int res = (rand() % 30) + 1;
    Input input{note};
    int g = co_await input;
    cout << "coroutine: You guess " << g << endl;
    co_yield (res > g ? 1 : (res == g ? 0 : -1));
    // co_await promise.yield_value()
    co_return res;
    // co_await promise.final_suspend();
}
int main()
{
    srand(time(nullptr));
    Note note;
    auto ret = Guess(note);
    cout << "main: make a guess ..." << endl;
    note.guess = 10;
    ret._h.resume(); // resume from co_await
    cout << "main: result is "
         << ((ret._h.promise()._out == 1)
                 ? "larger"
                 : ((ret._h.promise()._out == 0) ? "the same" : "smaller"))
         << endl;
    ret._h.resume(); // resume from co_yield
    if (ret._h.done())
    {
        cout << "main: the result is " << ret._h.promise()._res << endl;
    }
}

g++ -std=c++20 -fcoroutines -o output_file input_file.cpp

g++ -std=c++20 -fcoroutines -o output_file input_file.cpp -L/path/to/lib -lboost_system

/opt/rh/devtoolset-10/root/usr/lib/gcc/x86_64-redhat-linux/10/

#include <iostream>
#include <coroutine>         //协程
#include <czmq.h>            //zeroMQ
#include <hiredis/hiredis.h> //redis
using namespace std;
// 封装协程异步通信代码
class AsyncCommunication {
public:
    AsyncCommunication(zsock_t* socket, redisContext* redis) : socket_(socket), redis_(redis) {}
    void operator()(coroutine_handle<> handle) {
        zmsg_t* msg = zmsg_recv(socket_);
        if (msg) {
            // 将消息发送到消息队列中
            redisReply* reply = (redisReply*)redisCommand(redis_, "LPUSH message_queue %s", zmsg_popstr(msg));
            freeReplyObject(reply);
            zmsg_destroy(&msg);
        }
        handle.resume();
    }
private:
    zsock_t* socket_;
    redisContext* redis_;
};
// 封装处理消息代码
class ProcessMessage {
public:
    ProcessMessage(redisContext* redis) : redis_(redis) {}
    void operator()() {
        while (true) {
            redisReply* reply = (redisReply*)redisCommand(redis_, "BRPOP message_queue 0");
            if (reply && reply->type == REDIS_REPLY_ARRAY && reply->elements == 2) {
                string message = reply->element[1]->str;
                // 处理消息并将结果存储到Redis中
                redisReply* result = (redisReply*)redisCommand(redis_, "SET result_key %s", "result");
                freeReplyObject(result);
            }
            freeReplyObject(reply);
        }
    }
private:
    redisContext* redis_;
};
// 封装协程异步通信任务
template<typename Func>
void async_communication(zsock_t* socket, redisContext* redis, Func&& func) {
    coroutine_handle<> handle = coroutine_handle<>::from_address(nullptr);
    while (true) {
        AsyncCommunication async_communication(socket, redis);
        async_communication(handle);
        func();
    }
}
int main() {
    // 初始化ZeroMQ和Redis
    zctx_t* context = zctx_new();
    zsock_t* socket = zsock_new_pull("tcp://*:5555");
    redisContext* redis = redisConnect("localhost", 6379);
    // 创建处理消息任务
    ProcessMessage process_message(redis);
    std::thread process_thread(process_message);
    // 创建协程异步通信任务
    async_communication(socket, redis, [&process_thread]() {
        // 在每次通信完成后检查处理消息任务是否存活，如果已经结束则重新启动
        if (process_thread.joinable()) {
            process_thread.join();
            process_thread = std::thread(process_message);
        }
    });
    // 清理资源
    process_thread.join();
    redisFree(redis);
    zsock_destroy(&socket);
    zctx_destroy(&context);
    return 0;
}