无死锁风险的stdin/stdout/stderr全量重定向是否有单线程方案

你不需要创建多线程来规避死锁，使用IO多路复用接口即可实现单线程无死锁的三流重定向。

死锁产生的核心原因 #

管道的内核缓冲区容量有限，当你串行处理多个流时，很容易出现双向等待：

• 子进程往stdout/stderr写满缓冲区后被阻塞，无法继续运行读取你发的stdin数据
• 你这边还在等待把stdin全部写完再读stdout/stderr，或者只在读其中一个流，导致另一个流的缓冲区永远得不到清空

单线程实现核心逻辑 #

用select/poll这类IO多路复用接口同时监听所有需要操作的管道文件描述符，哪个流就绪就处理哪个，不需要额外线程：

实现步骤 #

• 第一步：将所有和子进程通信的管道（stdin写端、stdout读端、stderr读端）设置为非阻塞模式
• 第二步：维护三个状态标记：stdin剩余未写长度、stdout是否读取完成、stderr是否读取完成，只要三个状态未全部完成就持续运行循环
• 第三步：每次循环前构造监听事件集合：
  • 若还有stdin数据未写，将stdin写端加入可写事件监听
  • 若stdout未读完，将stdout读端加入可读事件监听
  • 若stderr未读完，将stderr读端加入可读事件监听
• 第四步：调用多路复用接口等待事件就绪，按就绪事件处理对应流：
  • stdin写端就绪：写入尽可能多的未发送数据，更新剩余未写长度，全部写完后主动关闭stdin写端，通知子进程输入结束
  • stdout读端就绪：读取尽可能多的数据存入目标缓冲区，若read()返回0说明子进程已关闭该流，标记stdout读取完成
  • stderr读端就绪：逻辑同stdout，读取完成后标记对应状态
• 第五步：所有流处理完成后，调用waitpid回收子进程状态即可

注意事项 #

必须为所有管道fd设置非阻塞标识，避免极端场景下read/write意外阻塞。stdin全部写入完成后必须主动关闭写端，否则子进程会一直等待输入无法退出。

方案优势 #

相比多线程方案，单线程多路复用的实现完全没有线程创建、调度切换的额外开销，非常适合你所说的多工作线程高频调用的场景。

// 简化实现示例
int stdin_write_fd = io_redirector.stdin_write();
int stdout_read_fd = io_redirector.stdout_read();
int stderr_read_fd = io_redirector.stderr_read();

// 设置所有fd为非阻塞
fcntl(stdin_write_fd, F_SETFL, O_NONBLOCK);
fcntl(stdout_read_fd, F_SETFL, O_NONBLOCK);
fcntl(stderr_read_fd, F_SETFL, O_NONBLOCK);

const char* stdin_buf = io_redirector.stdin_data();
size_t stdin_remaining = io_redirector.stdin_size();
bool stdout_done = false, stderr_done = false;

while (stdin_remaining > 0 || !stdout_done || !stderr_done) {
    fd_set read_fds, write_fds;
    FD_ZERO(&read_fds);
    FD_ZERO(&write_fds);
    int max_fd = -1;

    if (stdin_remaining > 0) {
        FD_SET(stdin_write_fd, &write_fds);
        max_fd = std::max(max_fd, stdin_write_fd);
    }
    if (!stdout_done) {
        FD_SET(stdout_read_fd, &read_fds);
        max_fd = std::max(max_fd, stdout_read_fd);
    }
    if (!stderr_done) {
        FD_SET(stderr_read_fd, &read_fds);
        max_fd = std::max(max_fd, stderr_read_fd);
    }

    if (select(max_fd + 1, &read_fds, &write_fds, nullptr, nullptr) < 0) {
        if (errno == EINTR) continue;
        abort();
    }

    // 处理stdin写
    if (FD_ISSET(stdin_write_fd, &write_fds)) {
        ssize_t wrote = write(stdin_write_fd, stdin_buf, stdin_remaining);
        if (wrote > 0) {
            stdin_buf += wrote;
            stdin_remaining -= wrote;
            if (stdin_remaining == 0) {
                close(stdin_write_fd);
            }
        }
    }

    // 处理stdout读
    if (FD_ISSET(stdout_read_fd, &read_fds)) {
        char buf[4096];
        ssize_t n = read(stdout_read_fd, buf, sizeof(buf));
        if (n > 0) {
            io_redirector.append_stdout(buf, n);
        } else if (n == 0) {
            stdout_done = true;
            close(stdout_read_fd);
        }
    }

    // 处理stderr读
    if (FD_ISSET(stderr_read_fd, &read_fds)) {
        char buf[4096];
        ssize_t n = read(stderr_read_fd, buf, sizeof(buf));
        if (n > 0) {
            io_redirector.append_stderr(buf, n);
        } else if (n == 0) {
            stderr_done = true;
            close(stderr_read_fd);
        }
    }
}

// 回收子进程
int status;
if (::waitpid(pid, &status, 0) == -1) { abort(); }

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