C++20协程无法直接异步读写文件，因标准库无异步I/O；必须用线程池+可等待封装（如packaged_task或boost.asio）实现伪异步，注意线程安全与磁盘I/O瓶颈。

协程不能直接读写文件，std::filesystem 和 std::fstream 都是同步阻塞的

这是最关键的前置认知：C++20 标准库中没有提供任何异步 I/O 接口，std::ifstream、std::ofstream、std::fstream 全部是同步阻塞调用。哪怕你用 co_await 包裹它们的读写操作，协程也会在系统调用处挂起整个线程（即退化为“伪异步”），无法释放线程资源。

真正可行的路径只有一条：把阻塞 I/O 操作移交到线程池执行，并让协程等待其完成 —— 这本质是“协程 + 线程池”的组合模式，不是纯内核/IOCP/epoll 异步。

• 不要试图给 std::fstream::read() 加 co_await：它不是可等待类型，编译不过
• std::jthread 或 std::thread 可用于后台执行，但需配合 std::promise/std::future 或 std::packaged_task 构造可等待对象
• 若追求高性能或跨平台异步文件 I/O，必须依赖系统 API：io_uring（Linux）、OVERLAPPED+ReadFileEx（Windows）、或第三方库如 libuv、boost.asio

用 std::packaged_task + 协程实现可等待的文件读取

核心思路是把同步读取封装成一个能返回 std::future 的任务，再通过自定义 awaiter 让协程能 co_await 它。

以下是最小可行示例（仅读取）：

struct async_file_reader {
    std::string path;

    struct awaiter {
        std::future fut;
        bool await_ready() const noexcept { return fut.wait_for(std::chrono::seconds(0)) == std::future_status::ready; }
        void await_suspend(std::coroutine_handle<> h) const {
            std::thread([fut = std::move(const_cast(this)->fut), h]() mutable {
                auto result = fut.get();
                h.resume();
            }).detach();
        }
        std::string await_resume() { return fut.get(); }
    };

    auto operator co_await() {
        auto task = std::packaged_task{[path = this->path]() -> std::string {
            std::ifstream f(path, std::ios::binary);
            if (!f) throw std::runtime_error("open failed: " + path);
            std::string buf(std::istreambuf_iterator{f}, {});
            return buf;
        }};
        auto fut = task.get_future();
        std::thread(std::move(task)).detach();
        return awaiter{std::move(fut)};
    }
};

注意：await_suspend 中另起线程调用 resume() 是危险的（竞态），真实项目应使用线程安全的调度器（如单线程 event loop）或 std::execution::schedule（C++23）替代。

为什么不用 std::async？它和协程不兼容

std::async 返回的 std::future 不支持直接 co_await —— 它没有 await_ready/await_suspend/await_resume 成员函数。强行包装会触发未定义行为或编译失败。

• std::async 默认策略是 std::launch::deferred，首次 get() 才执行，无法满足“立即提交到后台”的需求
• 即使设为 std::launch::async，也无法控制线程生命周期，容易导致 std::future 被销毁时线程仍在运行
• 更严重的是：std::future::wait() 会阻塞当前线程，破坏协程“非阻塞挂起”的语义

真正生产可用的方案：用 boost::asio::thread_pool + 自定义 awaitable

Boost.Asio 提供了成熟线程池和 awaitable 封装能力，比手写更安全。关键点在于用 boost::asio::post 提交任务，并返回一个可等待对象：

template
auto post_to_pool(boost::asio::thread_pool& pool, Func&& f) {
    struct awaitable {
        boost::asio::thread_pool& pool;
        std::decay_t func;
        bool await_ready() const noexcept { return false; }
        void await_suspend(std::coroutine_handle<> h) const {
            boost::asio::post(pool, [h, f = std::move(func)]() mutable {
                std::move(f)();
                h.resume();
            });
        }
        void await_resume() const noexcept {}
    };
    return awaitable{pool, std::forward(f)};
}

然后这样用：

boost::asio::thread_pool pool(4);
co_await post_to_pool(pool, []{
    std::ofstream f("out.bin", std::ios::binary);
    f.write(data.data(), data.size());
});

这个模式可复用、线程安全、调度可控。但要注意：文件句柄在多线程间共享需加锁，且频繁小文件 I/O 仍可能成为瓶颈 —— 协程解决的是“等待”问题，不是“系统调用开销”问题。

最易被忽略的一点：异步文件读写真正的瓶颈往往不在用户代码，而在磁盘随机寻道、页缓存竞争、或 O_DIRECT 对齐要求。协程本身不加速磁盘，只帮你更优雅地组织等待逻辑。