**使用C++20协程实现异步文件读取**

作者

C++20引入的协程（coroutines）提供了一种简洁而高效的方式来处理异步操作。与传统的回调或多线程方式相比，协程能够让代码保持同步的直观风格，同时隐藏掉事件循环和线程切换的细节。本文将以文件读取为例，演示如何使用协程实现异步文件读取，并讨论其性能优势与使用场景。

1. 协程基本概念

协程通过co_await、co_yield和co_return关键字实现。协程的执行被拆分成若干“挂起点”（suspend points），在挂起时会返回控制权给调用者，随后再恢复执行。

在异步IO的场景里，协程的挂起点通常对应一次IO请求的完成事件。通过将IO事件封装成可等待对象（awaitable），我们可以在协程内部使用co_await等待事件，而不需要手动注册回调。

2. 需要的工具与依赖

  • C++20编译器（如g++-13、clang++-15或MSVC 19.34+）
  • Boost.Asio 1.74+（支持C++20协程）
  • 标准库（` `、“、“、“等）

注：Boost.Asio已经内置了协程支持，无需额外包装。

3. 实现思路

  1. 创建一个异步文件读取器：利用Boost.Asio的streambuf和async_read接口。
  2. 包装为协程友好的 awaitable：实现operator co_await，在协程挂起时启动异步IO，在完成后恢复。
  3. 在主协程中读取文件：使用co_await等待文件读取完成，得到数据后继续处理。

4. 代码实现

// async_file_reader.hpp
#pragma once
#include <boost/asio.hpp>
#include <iostream>
#include <string>

namespace asio = boost::asio;
using asio::ip::tcp;

// 一个简易的异步文件读取器，返回 std::string
class AsyncFileReader {
public:
    explicit AsyncFileReader(asio::io_context& io)
        : io_context_(io), executor_(asio::make_strand(io)) {}

    // awaitable接口
    struct awaitable {
        AsyncFileReader& reader_;
        std::string filename_;
        std::string result_;
        bool done_ = false;

        awaitable(AsyncFileReader& r, std::string f)
            : reader_(r), filename_(std::move(f)) {}

        // 协程挂起时的实现
        bool await_ready() const noexcept { return false; }

        // 挂起点，启动异步IO
        void await_suspend(asio::coroutine_handle<> h) {
            // 以文本模式打开文件
            std::ifstream file(filename_, std::ios::binary);
            if (!file) {
                std::cerr << "Cannot open file: " << filename_ << std::endl;
                h.resume(); // 立即恢复
                return;
            }

            // 读取文件内容到 result_
            file.seekg(0, std::ios::end);
            result_.resize(file.tellg());
            file.seekg(0);
            file.read(&result_[0], result_.size());

            // 模拟异步延迟（1 ms）
            asio::steady_timer timer(reader_.io_context_, std::chrono::milliseconds(1));
            timer.async_wait([h](const boost::system::error_code&) { h.resume(); });
        }

        // 协程恢复时返回值
        std::string await_resume() { return result_; }
    };

    awaitable read_file(std::string filename) {
        return awaitable(*this, std::move(filename));
    }

private:
    asio::io_context& io_context_;
    asio::strand<asio::io_context::executor_type> executor_;
};
// main.cpp
#include "async_file_reader.hpp"
#include <boost/asio.hpp>
#include <iostream>

namespace asio = boost::asio;
using asio::ip::tcp;

int main() {
    asio::io_context io;

    AsyncFileReader reader(io);

    auto main_coroutine = [&]() -> asio::awaitable <void> {
        std::string content = co_await reader.read_file("sample.txt");
        std::cout << "文件大小: " << content.size() << " 字节\n";
        std::cout << "内容前100个字符:\n" << content.substr(0, 100) << std::endl;
    }();

    // 运行协程
    asio::co_spawn(io, std::move(main_coroutine), asio::detached);
    io.run(); // 阻塞直到所有协程完成

    return 0;
}

编译指令（g++）：

g++ -std=c++20 -I /usr/include/boost -pthread main.cpp -o async_file_reader

运行后即可看到文件内容的大小与前100个字符。

5. 性能与优势

传统方式 协程方式
回调嵌套 直观同步语义
线程开销 事件循环，避免线程切换
代码难以维护 结构清晰，易于调试
错误处理困难 与异常机制自然集成
  • 事件驱动：所有IO操作都在单线程事件循环中完成，消除了多线程同步开销。
  • 可组合性：多个协程可以轻松串联，实现复杂的异步流程。
  • 易读易写：代码接近同步写法，降低认知成本。

6. 使用场景

  1. 高并发网络服务：如HTTP/HTTPS服务器、WebSocket处理。
  2. 批量文件处理：一次性读取或写入大量文件时，避免阻塞主线程。
  3. 嵌入式系统：资源受限，协程可以在单线程下实现多任务。

7. 进一步阅读

  • Boost.Asio 官方文档：介绍协程与异步IO的使用细节。
  • cppreference.com：C++20协程语法和标准库支持。
  • 《Effective Modern C++》：深入理解C++11/14/17/20的最佳实践。

结语

C++20的协程为异步编程带来了革命性的简化。通过协程与Boost.Asio的结合，我们可以像编写同步代码那样直观地实现高性能的异步文件读取。随着更多标准库组件对协程的支持，未来的C++开发将更加灵活与高效。祝你编码愉快!

发表评论