Boost.Process v2：异步读输出与进程终止检查的竞态问题求解

问题场景 #

使用Boost.Process v2和C++20协程实现子进程启动与输出读取时，存在竞态问题：有时无法捕获子进程的全部输出，剩余数据仍留在管道缓冲区中，读取管道的协程尚未完成。相关实现代码如下：

子进程与管道读取代码 #

boost::asio::io_context gContext;
namespace bp = boost::process::v2;
struct Subprocess {
  bp::process process;
  std::string output;
};

// ...

auto pipe_stdout = std::make_unique<boost::asio::readable_pipe>(gContext);
auto pipe_stderr = std::make_unique<boost::asio::readable_pipe>(gContext);
auto subprocess = std::make_unique<Subprocess>(Subprocess{
    bp::process(gContext, "/bin/sh", { "-c", "my command" },
                bp::process_stdio{ nullptr, *pipe_stdout, *pipe_stderr }),
    std::string{} });
for (auto* pipe : { &pipe_stdout, &pipe_stderr }) {
  boost::asio::co_spawn(
      gContext,
      [pipe = std::move(*pipe),
       output = &subprocess->output]() -> boost::asio::awaitable<void> {
        while (true) {
          std::array<char, 1024> buf;
          size_t len = co_await pipe->async_read_some(
              boost::asio::buffer(buf), boost::asio::use_awaitable);
          if (len == 0 && !pipe->is_open()) {
            co_return;
          }
          output->append(buf.data(), len);
        }
      },
      boost::asio::detached);
}

进程结束回调代码 #

subprocess->process.async_wait(
    [this, p = subprocess.get()](bp::error_code ec, int exit_code) {
      assert(!ec);
      auto it = std::ranges::find_if(
        running_, [p](const auto& up) { return up.get() == p; });
      finished_.emplace_back(std::move(*it));
      running_.erase(it);
    });

主循环代码 #

while (true) {
  while (!running_.empty() && finished_.empty()) {
    gContext.run_one();
  }
  if (finished_.empty()) {
    continue;
  }
  // process finished_.back(), get its output, etc.
  finished_.pop_back();
}

问题根源 #

进程退出的async_wait回调可能在管道读取协程完成前触发，导致主循环提前将子进程移到finished_列表并处理，此时管道中剩余的输出还未被读取到output字符串中，最终捕获的输出不完整。

解决方案 #

1. 将进程等待与管道读取合并到同一协程 #

把管道读取和进程等待逻辑整合到单个协程中，确保只有当所有管道数据读取完毕且进程退出后，才标记子进程为完成，彻底消除竞态：

boost::asio::co_spawn(gContext, [this, subprocess = std::move(subprocess), 
                                 pipe_stdout = std::move(pipe_stdout), 
                                 pipe_stderr = std::move(pipe_stderr)]() -> boost::asio::awaitable<void> {
    // 封装单个管道的读取逻辑
    auto read_pipe = [](boost::asio::readable_pipe pipe, std::string* output) -> boost::asio::awaitable<void> {
        std::array<char, 1024> buf;
        while (true) {
            boost::system::error_code ec;
            size_t len = co_await pipe.async_read_some(
                boost::asio::buffer(buf), boost::asio::redirect_error(boost::asio::use_awaitable, ec));
            if (ec == boost::asio::error::eof) {
                co_return; // 管道写端关闭，读取完成
            } else if (ec) {
                throw boost::system::system_error(ec);
            }
            output->append(buf.data(), len);
        }
    };

    // 启动两个管道的读取任务
    auto stdout_task = read_pipe(std::move(*pipe_stdout), &subprocess->output);
    auto stderr_task = read_pipe(std::move(*pipe_stderr), &subprocess->output);

    // 等待进程退出
    boost::system::error_code ec;
    int exit_code = co_await subprocess->process.async_wait(
        boost::asio::redirect_error(boost::asio::use_awaitable, ec));
    if (ec) {
        throw boost::system::system_error(ec);
    }

    // 等待两个管道的读取任务全部完成
    co_await std::move(stdout_task);
    co_await std::move(stderr_task);

    // 所有操作完成，将子进程移到finished_列表
    auto it = std::ranges::find_if(running_, [p = subprocess.get()](const auto& up) { 
        return up.get() == p; 
    });
    finished_.emplace_back(std::move(*it));
    running_.erase(it);
}, boost::asio::detached);

2. 修正管道读取的终止条件 #

原代码中len == 0 && !pipe->is_open()的判断逻辑错误，正确的终止条件应该是捕获boost::asio::error::eof错误——当子进程退出时，管道的写端会被操作系统关闭，此时async_read_some会返回eof，标志着数据读取完毕。

3. 保证容器访问的线程安全（可选） #

如果存在多线程调用io_context.run()的场景，需要对running_和finished_的访问添加互斥锁，避免并发修改导致的未定义行为。

关键原理 #

子进程退出时，其标准输出/标准错误管道的写端会被操作系统自动关闭，此时读取管道的协程会收到eof信号。通过在同一协程中先等待进程退出，再等待管道读取完成（或反之），可以确保所有输出数据被完整读取后，再将子进程标记为完成，彻底解决竞态问题。

内容的提问来源于stack exchange，提问作者jhasse