C++20 协程深度剖析：原理、应用与异步并发的未来

2025/4/29 09:04:11 283 0 0 0

作为一名 C++ 开发者，你是否还在为异步编程的复杂性而苦恼？传统的回调地狱、多线程锁竞争，是否让你感觉力不从心？C++20 引入的协程（Coroutines）正是解决这些问题的利器。它以更轻量级、更易于理解的方式，实现了异步编程和并发编程，极大地提升了代码的可读性和可维护性。

本文将带你深入了解 C++20 协程的原理、应用场景，并分析其在异步并发编程中的优劣势。无论你是已经对协程有所了解，还是初次接触，相信都能从中获益。

1. 协程的本质：可暂停与恢复的函数

简单来说，协程是一种可以暂停执行，并在稍后恢复执行的函数。与传统函数不同，协程在暂停时不会导致线程阻塞，而是将执行权交给其他协程或调度器。这种特性使得协程能够在单个线程内实现并发，避免了多线程带来的锁竞争和上下文切换开销。

1.1 协程的关键概念

协程函数（Coroutine Function）： 包含 co_return、co_yield 或 co_await 关键字的函数。这些关键字标志着函数可以被挂起和恢复。
Promise 对象（Promise Object）： 协程的“管家”，负责管理协程的状态、返回值和异常。它定义了协程的行为，例如如何挂起、恢复和完成。
Coroutine Handle： 一个轻量级的句柄，用于控制协程的生命周期，例如恢复协程的执行或销毁协程。
Awaitable 对象： 用于表示一个异步操作。当协程遇到 co_await 表达式时，它会挂起，直到 Awaitable 对象表示的异步操作完成。

1.2 协程的工作流程

调用协程函数： 当你调用一个协程函数时，编译器会生成一个 Promise 对象，并将其传递给协程函数。
协程开始执行： 协程函数开始执行，直到遇到 co_await、co_yield 或 co_return 关键字。
协程挂起： 当协程遇到 co_await 表达式时，它会检查 Awaitable 对象是否已经准备好。如果未准备好，协程将挂起，并将执行权交给调度器。
异步操作完成： 当 Awaitable 对象表示的异步操作完成时，调度器会恢复协程的执行。
协程恢复执行： 协程从 co_await 表达式处恢复执行，并获取异步操作的结果。
协程完成： 当协程执行到 co_return 语句时，它将返回值存储在 Promise 对象中，并通知调度器协程已完成。

2. C++20 协程的语法与特性

2.1 `co_return`：返回值并结束协程

co_return 语句用于从协程函数返回值，并结束协程的执行。它的语法与 return 语句类似，但有一些关键的区别：

co_return 语句只能在协程函数中使用。
co_return 语句会将返回值存储在 Promise 对象中。
co_return 语句会通知调度器协程已完成。

pp
#include <iostream>
#include <coroutine>

struct ReturnObject {
  struct promise_type {
    ReturnObject get_return_object() { return {}; }
    std::suspend_never initial_suspend() { return {}; }
    std::suspend_never final_suspend() noexcept { return {}; }
    void return_void() {}
    void unhandled_exception() {}
  };
};

ReturnObject MyCoroutine() {
  std::cout << "Coroutine started\n";
  co_return;
  std::cout << "Coroutine finished\n"; // This line will not be executed
}

int main() {
  MyCoroutine();
  std::cout << "Main function finished\n";
  return 0;
}

2.2 `co_yield`：生成值并暂停协程

co_yield 语句用于生成一个值，并将协程挂起。它的语法类似于 return 语句，但有一些关键的区别：

co_yield 语句只能在协程函数中使用。
co_yield 语句会将生成的值存储在 Promise 对象中。
co_yield 语句会暂停协程的执行，并将执行权交给调用者。
调用者可以通过 resume() 方法恢复协程的执行，并获取下一个生成的值。

#include <iostream>
#include <coroutine>

struct Generator {
  struct promise_type {
    int value_;
    std::exception_ptr exception_;

    Generator get_return_object() {
      return Generator{std::coroutine_handle<promise_type>::from_promise(*this)};
    }
    std::suspend_never initial_suspend() { return {}; }
    std::suspend_always final_suspend() noexcept { return {}; }
    void unhandled_exception() { exception_ = std::current_exception(); }
    void return_void() {}
    std::suspend_always yield_value(int value) {
      value_ = value;
      return {};
    }
  };
  std::coroutine_handle<promise_type> coroutine_;
  Generator(std::coroutine_handle<promise_type> coroutine) : coroutine_(coroutine) {}
  ~Generator() {
    if (coroutine_) {
      coroutine_.destroy();
    }
  }

  struct iterator {
    std::coroutine_handle<promise_type> coroutine_;
    iterator(std::coroutine_handle<promise_type> coroutine) : coroutine_(coroutine) {}
    iterator& operator++() {
      coroutine_.resume();
      return *this;
    }
    bool operator!=(const iterator& other) {
      return !coroutine_.done();
    }
    int operator*() {
      return coroutine_.promise().value_;
    }
  };

  iterator begin() {
    coroutine_.resume();
    return iterator(coroutine_);
  }
  iterator end() { return iterator{nullptr}; }
};

Generator GenerateNumbers(int max) {
  for (int i = 0; i < max; ++i) {
    co_yield i;
  }
}

int main() {
  for (int number : GenerateNumbers(5)) {
    std::cout << number << std::endl;
  }
  return 0;
}

2.3 `co_await`：等待异步操作完成

co_await 表达式用于等待一个 Awaitable 对象表示的异步操作完成。当协程遇到 co_await 表达式时，它会挂起，直到 Awaitable 对象准备好。co_await 是协程实现异步编程的关键。

#include <iostream>
#include <coroutine>
#include <future>

struct MyAwaitable {
  std::future<int> future_;

  bool await_ready() { return future_.is_ready(); }
  void await_suspend(std::coroutine_handle<> handle) {
    future_.then([handle](auto) { handle.resume(); });
  }
  int await_resume() { return future_.get(); }
};


std::future<int> ComputeValueAsync() {
  return std::async(std::launch::async, []() { return 42; });
}


std::coroutine_handle<> global_handle;

struct Task {
    struct promise_type {
        Task get_return_object() {
            return Task{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_never initial_suspend() noexcept { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };
    std::coroutine_handle<promise_type> handle;
    Task(std::coroutine_handle<promise_type> h) : handle(h) {}
    ~Task() {
        if (handle) handle.destroy();
    }
}; 

Task MyCoroutine() {
  MyAwaitable awaitable{ComputeValueAsync()};
  int result = co_await awaitable;
  std::cout << "Result: " << result << std::endl;
}

int main() {
  MyCoroutine();
  return 0;
}

2.4 自定义 Promise 对象和 Awaitable 对象

C++20 协程提供了强大的自定义能力，你可以通过自定义 Promise 对象和 Awaitable 对象来控制协程的行为。

自定义 Promise 对象： 你可以定义自己的 Promise 对象来管理协程的状态、返回值和异常。你需要实现 Promise 对象的以下方法：
- get_return_object()：返回一个 Coroutine Handle，用于控制协程的生命周期。
- initial_suspend()：决定协程在开始执行时是否挂起。
- final_suspend()：决定协程在结束执行时是否挂起。
- return_void() 或 return_value(value)：处理协程的返回值。
- unhandled_exception()：处理协程中未处理的异常。
- yield_value(value): 处理 co_yield 语句生成的值。
自定义 Awaitable 对象： 你可以定义自己的 Awaitable 对象来表示异步操作。你需要实现 Awaitable 对象的以下方法：
- await_ready()：检查异步操作是否已经准备好。
- await_suspend(std::coroutine_handle<> handle)：挂起协程，并将执行权交给调度器。
- await_resume()：恢复协程的执行，并获取异步操作的结果。

3. 协程的应用场景

协程在异步编程和并发编程中有着广泛的应用，以下是一些常见的应用场景：

异步 I/O： 协程可以用于处理异步 I/O 操作，例如网络请求、文件读写等。通过使用协程，你可以避免阻塞线程，提高程序的响应速度。
并发任务： 协程可以用于执行并发任务，例如并行计算、图像处理等。通过使用协程，你可以充分利用多核 CPU 的性能，提高程序的执行效率。
事件驱动编程： 协程可以用于实现事件驱动编程模型。通过使用协程，你可以将事件处理逻辑与事件循环分离，提高代码的可读性和可维护性。
游戏开发： 协程可以用于实现游戏中的 AI、动画、物理模拟等功能。通过使用协程，你可以简化游戏逻辑，提高游戏性能。
Web 服务器： 协程可以用于构建高性能的 Web 服务器。通过使用协程，你可以处理大量的并发请求，提高服务器的吞吐量。

3.1 协程在异步 I/O 中的应用

传统的异步 I/O 通常使用回调函数来实现，这会导致代码难以理解和维护。协程可以简化异步 I/O 的代码，使其更易于理解和维护。

例如，以下代码使用协程实现了一个简单的异步文件读取操作：

#include <iostream>
#include <fstream>
#include <string>
#include <future>
#include <coroutine>

struct AwaitableFileRead {
  std::string filename;
  std::string content;
  std::promise<void> promise;

  bool await_ready() const { return false; }
  void await_suspend(std::coroutine_handle<> h) {
    std::ifstream file(filename);
    if (file.is_open()) {
      std::string line;
      while (getline(file, line)) {
        content += line + "\n";
      }
      file.close();
      promise.set_value();
    } else {
      promise.set_exception(std::make_exception_ptr(std::runtime_error("Could not open file")));
    }
    h.resume();
  }
  std::string await_resume() {
      promise.get_future().get();
      return content;
  }
};

struct Task {
    struct promise_type {
        Task get_return_object() {
            return Task{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_never initial_suspend() noexcept { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };
    std::coroutine_handle<promise_type> handle;
    Task(std::coroutine_handle<promise_type> h) : handle(h) {}
    ~Task() {
        if (handle) handle.destroy();
    }
}; 

Task ReadFileAsync(const std::string& filename) {
  AwaitableFileRead awaitable{filename};
  std::string content = co_await awaitable;
  std::cout << "File content: " << content << std::endl;
}

int main() {
  ReadFileAsync("example.txt");
  return 0;
}

3.2 协程在并发任务中的应用

协程可以用于执行并发任务，例如并行计算、图像处理等。通过使用协程，你可以充分利用多核 CPU 的性能，提高程序的执行效率。

例如，以下代码使用协程实现了一个简单的并行计算操作：

#include <iostream>
#include <vector>
#include <numeric>
#include <future>
#include <coroutine>

struct AwaitableCalculation {
  int start;
  int end;
  std::promise<int> promise;

  bool await_ready() const { return false; }
  void await_suspend(std::coroutine_handle<> h) {
    int sum = 0;
    for (int i = start; i <= end; ++i) {
      sum += i;
    }
    promise.set_value(sum);
    h.resume();
  }
  int await_resume() { return promise.get_future().get(); }
};

struct Task {
    struct promise_type {
        Task get_return_object() {
            return Task{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_never initial_suspend() noexcept { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };
    std::coroutine_handle<promise_type> handle;
    Task(std::coroutine_handle<promise_type> h) : handle(h) {}
    ~Task() {
        if (handle) handle.destroy();
    }
}; 

Task CalculateSumAsync(int start, int end) {
  AwaitableCalculation awaitable{start, end};
  int sum = co_await awaitable;
  co_return;
}

int main() {
  std::vector<Task> tasks;
  int num_tasks = 4;
  int total_sum = 0;
  int chunk_size = 100 / num_tasks;

  for (int i = 0; i < num_tasks; ++i) {
    int start = i * chunk_size + 1;
    int end = (i == num_tasks - 1) ? 100 : (i + 1) * chunk_size;
    tasks.push_back(CalculateSumAsync(start, end));
  }

  // Wait for all tasks to complete (this is a simplified example, proper synchronization would be needed)
  for (auto& task : tasks) {
        task.handle.resume();
  }

  
  std::cout << "Total sum: " << total_sum << std::endl;
  return 0;
}

4. 协程的优势与劣势

4.1 优势

更高的性能： 协程避免了多线程带来的锁竞争和上下文切换开销，可以提高程序的性能。
更简单的代码： 协程可以简化异步编程的代码，使其更易于理解和维护。
更好的可读性： 协程可以使异步代码看起来像同步代码，提高代码的可读性。
更好的可维护性： 协程可以使异步代码更易于测试和调试，提高代码的可维护性。

4.2 劣势

学习曲线： 协程的概念和语法相对复杂，需要一定的学习成本。
调试困难： 协程的调试相对困难，因为协程的执行流程不是线性的。
库支持： 目前，C++20 协程的库支持还不够完善，需要自己实现一些常用的 Awaitable 对象。
栈空间限制： 协程的栈空间有限，如果协程中使用了大量的局部变量，可能会导致栈溢出。

5. 协程的未来发展

C++20 协程是一个非常有前景的技术，它将极大地简化异步编程和并发编程。随着 C++20 的普及，协程将在越来越多的领域得到应用。

未来，我们可以期待以下发展：

更完善的库支持： 随着 C++ 标准库的不断完善，将会提供更多常用的 Awaitable 对象，例如网络 I/O、文件 I/O 等。
更好的调试工具： 随着调试工具的不断发展，将会提供更好的协程调试支持，例如可以跟踪协程的执行流程、查看协程的状态等。
更广泛的应用： 随着协程的普及，它将在越来越多的领域得到应用，例如游戏开发、Web 服务器、人工智能等。

6. 总结

C++20 协程是一个强大的工具，可以帮助你编写更高效、更易于理解和维护的异步并发代码。虽然协程有一定的学习成本，但它的优势是显而易见的。如果你正在进行异步编程或并发编程，不妨尝试一下 C++20 协程，相信它会给你带来惊喜。

希望本文能够帮助你更好地理解 C++20 协程的原理、应用和未来发展。如果你有任何问题或建议，欢迎在评论区留言。

7. 实践建议

从简单的例子开始： 学习协程最好的方法是从简单的例子开始，例如打印一条消息、生成一个数字序列等。
阅读官方文档和示例代码： C++ 官方文档和示例代码是学习协程的重要资源。
尝试使用现有的协程库： 如果你不想自己实现 Awaitable 对象，可以尝试使用现有的协程库，例如 cppcoro。
参与社区讨论： 参与 C++ 社区的讨论，可以帮助你更好地理解协程，并解决遇到的问题。
在实际项目中应用协程： 只有在实际项目中应用协程，才能真正掌握协程的使用方法。

8. 常见问题

协程和线程有什么区别？
- 线程是操作系统调度的最小单元，而协程是用户态的轻量级线程。
- 线程的切换需要操作系统内核的参与，开销较大，而协程的切换只需要用户态的上下文切换，开销较小。
- 线程可以并行执行，而协程只能在单个线程内并发执行。
协程和回调函数有什么区别？
- 回调函数是一种事件驱动的编程模型，而协程是一种基于挂起和恢复的编程模型。
- 回调函数会导致代码难以理解和维护，而协程可以简化异步代码，使其更易于理解和维护。
- 回调函数容易产生回调地狱，而协程可以避免回调地狱。
协程的栈空间有多大？
- 协程的栈空间大小取决于编译器和操作系统的实现。
- 一般来说，协程的栈空间比线程的栈空间小，因此在使用协程时需要注意栈溢出的问题。
如何调试协程？
- 协程的调试相对困难，因为协程的执行流程不是线性的。
- 可以使用调试器来跟踪协程的执行流程，查看协程的状态。
- 可以使用日志来记录协程的执行过程，帮助定位问题。

希望这些常见问题解答能够帮助你更好地理解 C++20 协程。

AsyncMaster C++20 协程异步编程