C++ 视角下的进程、线程与协程：概念、原理及应用场景

• 展示了：
  • 父进程/子进程地址空间独立
  • fork + exec
  • 进程阻塞等待子进程完成

2. 线程（Thread）

概念（C++ 视角）

• 线程是进程中的最小执行单位。
• C++ 中可用 std::thread 创建。
• 同一进程内的线程共享内存（代码段、堆），但有自己的栈。

优点

缺点

应用场景

• 计算密集型任务：并行排序、矩阵运算（利用多核 CPU）
• I/O 密集型任务：服务器线程池
• 后台任务：日志线程、定时任务线程

2. 线程示例（std::thread）

用 C++ 标准库创建一个线程并等待其执行。

#include <iostream>
#include <thread>

void worker(int id) {
    std::cout << "Thread " << id << " is running.\n";
}

int main() {
    std::thread t(worker, 1); // 创建线程
    if (t.joinable()) {
        t.join(); // 等待线程结束
    }
    std::cout << "Thread finished.\n";
    return 0;
}

• 展示了：
  • 如何创建线程
  • 如何 join
  • 线程共享进程数据

3. 协程（Coroutine）

概念（C++ 视角）

• C++20 正式原生支持协程（co_await, co_yield, co_return）。
• 用户态调度：协程的切换在用户空间进行，不需要操作系统。
• 轻量级执行单元，数量可以达到几十万甚至百万级别。

原理简述

• 协程不会主动抢占 CPU，需要手动 co_await 等方式让出执行权。
• 和线程不同：协程不是系统级调度，而是语言/库层调度。

优点

缺点

应用场景

• 超高并发网络服务器（如用协程替代回调）
• 游戏引擎脚本系统（逻辑暂停/恢复很适合协程）
• GUI 程序的异步任务
• 异步 I/O（文件读写、socket 等）

3. 协程示例（C++20 coroutine）

使用 std::coroutine_handle + promise 自定义一个简单协程。实现一个'打印任务'协程，可暂停/恢复。

#include <iostream>
#include <coroutine>

// 协程返回对象
struct Task {
    struct promise_type {
        Task get_return_object() {
            return Task{ std::coroutine_handle<promise_type>::from_promise(*this) };
        }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::exit(1); }
    };
    std::coroutine_handle<promise_type> handle;
    Task(std::coroutine_handle<promise_type> h) : handle(h) {}
    ~Task() { if (handle) handle.destroy(); }
};

// 一个可挂起协程
Task myCoroutine() {
    std::cout << "Coroutine step 1\n";
    co_await std::suspend_always{}; // 暂停
    std::cout << "Coroutine step 2\n";
    co_await std::suspend_always{}; // 再暂停
    std::cout << "Coroutine finished\n";
}

int main() {
    auto task = myCoroutine(); // 创建协程（不会立即结束）
    std::cout << "Resume coroutine...\n";
    task.handle.resume();
    std::cout << "Resume again...\n";
    task.handle.resume();
    std::cout << "Resume last time...\n";
    task.handle.resume();
    return 0;
}

运行输出类似：

Coroutine step 1
Resume coroutine...
Coroutine step 2
Resume again...
Coroutine finished
Resume last time...

• 展示了：
  • 协程的挂起/恢复机制
  • 完全用户态，不需要线程/进程调度
  • C++20 协程语法：co_await、co_return

4. 三者的直观对比

总结

• 进程：最安全，但最重，适合隔离性强的任务
• 线程：共享内存并行执行，适合 CPU 密集任务
• 协程：超轻量级并发，适合 I/O 密集型和高并发服务器