C++协程和线程的区别？详细介绍一下C++协程

C++协程和线程的区别

• 线程是操作系统级别的资源，由操作系统负责调度和切换，每个线程都有自己的堆栈和执行上下文。线程之间的切换需要保存和恢复线程的执行上下文，这个过程有一定的开销。
• 协程是用户态的轻量级线程，协程的调度完全由用户控制，一个线程可以拥有多个协程，协程之间的切换不需要操作系统的干预，因此开销更小。协程也有自己的堆栈和执行上下文，但是协程的堆栈是动态分配的，可以根据需要增长或缩小，协程的执行上下文是保存在协程状态中的，协程状态是分配在堆上的内部对象。
• 线程是同步机制，即线程在执行过程中如果遇到阻塞，比如IO操作，就会让出CPU，等待阻塞结束后再继续执行。这样会导致线程的资源浪费和调度开销的增加。线程之间如果要共享数据，还需要使用锁机制来避免竞争和冲突，这也会增加复杂度和开销。
• 协程是异步机制，即协程在执行过程中可以主动挂起，让出CPU，然后在适当的时候再恢复执行。这样可以避免无意义的等待和切换，提高CPU的利用率。协程之间如果要共享数据，不需要使用锁机制，只需要判断状态就可以了，这也会降低复杂度和开销。

C++协程的基本概念和用法

• C++协程是在C++20标准中引入的一个新特性，目的是为了简化异步编程的模式，提高性能和效率。C++协程的实现主要依赖于三个新的关键字：co_await, co_yield, co_return，以及一些新的类型和库函数。
• C++协程是一种特殊的函数，它的返回类型必须是一个有promise_type成员类型的类型，比如std::future, std::generator, std::task等。这个promise_type类型是一个承诺对象，它负责生成协程函数的返回对象，提交协程的结果或异常，以及控制协程的启动和终止行为。
• C++协程可以使用co_await关键字来调用一个等待体对象，根据其内部定义决定其操作是挂起还是继续，以及挂起和恢复时的行为。等待体对象必须有await_ready, await_suspend, await_resume三个成员函数，或者重载了operator co_await的类型。一般而言，等待体对象可以表示一个异步操作，比如网络IO，文件读写，定时器等。
• C++协程可以使用co_yield关键字来挂起协程，并且产生一个值，这个值会保存在承诺对象中，通过yield_value函数。在协程外部可以通过承诺对象得到这个值。这个机制可以用来实现生成器，即按需产生值的函数。
• C++协程可以使用co_return关键字来终止协程，并且返回一个值，这个值会保存在承诺对象中，通过return_value函数。在协程外部可以通过承诺对象得到这个值。这个机制可以用来实现异步函数，即返回一个未来值的函数。
• C++协程的唯一标识是协程句柄，它是一个std::coroutine_handle模板类的实例，它可以用来恢复或销毁协程。协程句柄可以通过承诺对象的get_return_object函数或者from_promise静态函数得到。协程句柄还可以访问协程状态，即保存协程的上下文和数据的对象。

以下是一个简单的C++协程的例子，实现了一个生成斐波那契数列的函数：

#include 
#include 

// 定义一个生成器类型，用于返回协程函数的对象
template
struct generator {
    // 定义一个承诺类型，用于控制协程的行为
    struct promise_type {
        // 保存协程产生的值
        T value;
        // 生成协程函数的返回对象
        generator get_return_object() {
            // 从承诺对象中获取协程句柄
            return generator{ std::coroutine_handle::from_promise(*this) };
        }
        // 表示协程启动后不立即挂起
        std::suspend_never initial_suspend() {
            return {};
        }
        // 表示协程终止后不再恢复
        std::suspend_never final_suspend() noexcept {
            return {};
        }
        // 处理协程的返回值
        void return_void() {}
        // 处理协程的异常
        void unhandled_exception() {
            std::terminate();
        }
        // 保存协程的产生的值
        std::suspend_always yield_value(T val) {
            value = val;
            return {};
        }
    };

    // 保存协程句柄
    std::coroutine_handle handle;

    // 构造函数，从协程句柄初始化
    explicit generator(std::coroutine_handle h) : handle(h) {}

    // 析构函数，销毁协程
    ~generator() {
        if (handle) {
            handle.destroy();
        }
    }

    // 生成器不能被拷贝，只能被移动
    generator(const generator&) = delete;
    generator& operator=(const generator&) = delete;
    generator(generator&& other) noexcept : handle(other.handle) {
        other.handle = nullptr;
    }
    generator& operator=(generator&& other) noexcept {
        handle = other.handle;
        other.handle = nullptr;
        return *this;
    }

    // 返回协程产生的值
    T value() const {
        return handle.promise().value;
    }

    // 恢复协程的执行
    void resume() {
        handle.resume();
    }

    // 判断协程是否结束
    bool done() const {
        return handle.done();
    }
};

// 定义一个协程函数，返回一个生成器对象，用于生成斐波那契数列
generator fibonacci(int n) {
    int a = 0, b = 1;
    for (int i = 0; i < n; i++) {
        co_yield a; // 挂起协程，并产生一个值
        auto tmp = a;
        a = b;
        b = tmp + b;
    }
}

int main() {
    // 调用协程函数，得到一个生成器对象
    auto gen = fibonacci(10);
    // 循环访问生成器产生的值，直到协程结束
    while (!gen.done()) {
        std::cout << gen.value() << " "; // 输出协程产生的值
        gen.resume(); // 恢复协程的执行
    }
    std::cout << std::endl;
    return 0;
}

输出结果：

0 1 1 2 3 5 8 13 21 34

Cpp中的线程，纤程和协程 - 知乎 (zhihu.com) 

(73 封私信) 如何理解协程和线程，以及它们之间的区别？ - 知乎 (zhihu.com)