Ubuntu 16下boost::process标准输出重定向随机失败求解决方案

我之前也踩过Boost.Process的坑，这个模块确实是Boost里问题相对多的部分，尤其是官方文档里的异步IO示例经常跑不起来，相关论坛里吐槽的人也不少。针对你要获取进程完整二进制输出的核心需求，我整理了几个能避开死锁的同步实现思路：

核心问题分析 #

同步方式的死锁根源在于：如果子进程的stdout/stderr输出缓冲区被填满，子进程会阻塞等待父进程读取；而如果父进程先等待子进程退出再去读流，就会陷入互相卡死的局面。所以关键是要同时处理stdout和stderr的读取，不能串行等待。

可行的同步实现方案 #

方案1：用线程分别读取stdout和stderr #

启动两个独立线程，分别读取子进程的标准输出和标准错误，把数据写入线程安全的字节缓冲区，等子进程退出后再合并结果。这种方式能完美支持二进制数据，不会有std::string的编码或截断问题：

#include <boost/process.hpp>
#include <vector>
#include <thread>
#include <mutex>

namespace bp = boost::process;

std::vector<std::byte> read_full_binary_output(const std::string& cmd) {
    std::vector<std::byte> stdout_buf, stderr_buf;
    std::mutex mtx_out, mtx_err;

    bp::ipstream stdout_stream, stderr_stream;
    bp::child proc(cmd, bp::std_out > stdout_stream, bp::std_err > stderr_stream);

    // 读取stdout的线程逻辑
    auto read_stdout_task = [&]() {
        std::byte buffer[4096];
        std::streamsize bytes_read;
        while ((bytes_read = stdout_stream.read(reinterpret_cast<char*>(buffer), sizeof(buffer)).gcount()) > 0) {
            std::lock_guard<std::mutex> lock(mtx_out);
            stdout_buf.insert(stdout_buf.end(), buffer, buffer + bytes_read);
        }
    };

    // 读取stderr的线程逻辑
    auto read_stderr_task = [&]() {
        std::byte buffer[4096];
        std::streamsize bytes_read;
        while ((bytes_read = stderr_stream.read(reinterpret_cast<char*>(buffer), sizeof(buffer)).gcount()) > 0) {
            std::lock_guard<std::mutex> lock(mtx_err);
            stderr_buf.insert(stderr_buf.end(), buffer, buffer + bytes_read);
        }
    };

    std::thread t_out(read_stdout_task), t_err(read_stderr_task);
    proc.wait();
    t_out.join();
    t_err.join();

    // 按需合并输出（如果不需要区分stdout/stderr可以直接合并）
    stdout_buf.insert(stdout_buf.end(), stderr_buf.begin(), stderr_buf.end());
    return stdout_buf;
}

方案2：使用async_pipe配合同步读取 #

如果不想引入额外线程，可以试试Boost.Process的async_pipe，它允许更灵活的IO控制，只要确保在子进程退出前把所有数据读完就能避免死锁：

#include <boost/process.hpp>
#include <vector>
#include <array>

namespace bp = boost::process;

std::vector<std::byte> read_full_binary_output(const std::string& cmd) {
    bp::async_pipe stdout_pipe, stderr_pipe;
    bp::child proc(cmd, bp::std_out > stdout_pipe, bp::std_err > stderr_pipe);

    std::vector<std::byte> stdout_buf, stderr_buf;
    std::array<std::byte, 4096> buffer;

    // 读取stdout直到管道关闭
    while (true) {
        boost::system::error_code ec;
        std::size_t bytes_read = stdout_pipe.read_some(boost::asio::buffer(buffer), ec);
        if (ec == boost::asio::error::eof) break;
        if (ec) throw boost::system::system_error(ec);
        stdout_buf.insert(stdout_buf.end(), buffer.begin(), buffer.begin() + bytes_read);
    }

    // 读取stderr直到管道关闭
    while (true) {
        boost::system::error_code ec;
        std::size_t bytes_read = stderr_pipe.read_some(boost::asio::buffer(buffer), ec);
        if (ec == boost::asio::error::eof) break;
        if (ec) throw boost::system::system_error(ec);
        stderr_buf.insert(stderr_buf.end(), buffer.begin(), buffer.begin() + bytes_read);
    }

    proc.wait();
    stdout_buf.insert(stdout_buf.end(), stderr_buf.begin(), stderr_buf.end());
    return stdout_buf;
}

避坑提示 #

• 绝对不要先调用proc.wait()再去读流，这是死锁的重灾区，必须保证流读取和子进程等待并行进行，或者先读完所有流数据再等待子进程。
• 处理二进制数据时，一定要用字节容器（比如std::vector<std::byte>），别用std::string，避免因为null字符截断或编码转换导致数据损坏。
• 如果需要处理超大输出，可以考虑用内存映射文件或临时文件存储数据，避免内存占用过高。

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