Golang使用os.exec操作stdin/stdout/stderr时进程挂起问题求助

问题根因 #

• 执行顺序逻辑错误：cmd.Start()仅启动子进程，不会等待进程执行完成。你在启动后立刻读取 stderr 缓冲区，此时子进程还未产生任何 stderr 输出，拿到的永远是空值。
• 死锁核心原因：操作系统为管道分配的缓冲区大小固定（通常为 4KB~64KB）。如果子进程向 stdout 写入的内容超过缓冲区上限，进程会阻塞等待消费者读取 stdout 内容才能继续运行。你的代码没有任何消费 stdout 的逻辑就直接返回，子进程因 stdout 阻塞无法继续执行、也不会输出 stderr 到缓冲区，最终形成死锁。你之前仅处理 stdin 和 stdout 时未复现问题，只是因为测试时的 stdout 输出量小于管道默认缓冲区，没有触发写入阻塞，本质逻辑问题一直存在。
• 缺少进程资源回收逻辑：你没有调用 cmd.Wait() 等待子进程退出，会产生僵尸进程占用系统资源。
• 存在语法问题：b.String 是方法调用需加括号写为 b.String()，errors.New(b.String() 缺少右括号，同时你忽略了多个系统调用的返回错误，生产环境存在稳定性风险。

修复方案 #

场景1：可接受将 stdout 全部加载到内存返回 #

这种实现逻辑最简单，没有额外复杂度：

func runCmd(convCmd string, convArgs []string, inStream io.Reader) ([]byte, error) {
    var stderrBuf bytes.Buffer
    cmd := exec.Command(convCmd, convArgs...)
    
    stdin, err := cmd.StdinPipe()
    if err != nil {
        return nil, err
    }
    stdout, err := cmd.StdoutPipe()
    if err != nil {
        return nil, err
    }
    cmd.Stderr = &stderrBuf

    // 异步写入stdin，写入完成自动关闭管道
    go func() {
        defer stdin.Close()
        _, _ = io.Copy(stdin, inStream)
    }()

    if err := cmd.Start(); err != nil {
        return nil, err
    }

    // 先读取全部stdout，避免管道缓冲区满导致子进程阻塞
    stdoutContent, err := io.ReadAll(stdout)
    if err != nil {
        return nil, err
    }

    // 等待子进程执行完成，回收系统资源
    if err := cmd.Wait(); err != nil {
        // 优先返回stderr中的业务错误信息
        if stderrBuf.Len() > 0 {
            return stdoutContent, errors.New(stderrBuf.String())
        }
        return stdoutContent, err
    }

    return stdoutContent, nil
}

场景2：需要返回 stdout Reader 给上层流式读取（大文件场景适用） #

如果 stdout 数据量很大不能全部加载到内存，需要自定义 Reader 封装 stdout，在读取完成后自动收集错误：

import "sync"

type cmdReader struct {
    stdout    io.ReadCloser
    cmd       *exec.Cmd
    stderrBuf *bytes.Buffer
    err       error
    once      sync.Once
}

func (r *cmdReader) Read(p []byte) (n int, err error) {
    n, err = r.stdout.Read(p)
    if err == io.EOF {
        // stdout读取完成后等待子进程退出，收集错误
        r.once.Do(func() {
            waitErr := r.cmd.Wait()
            if r.stderrBuf.Len() > 0 {
                r.err = errors.New(r.stderrBuf.String())
                return
            }
            r.err = waitErr
        })
        if r.err != nil {
            return n, r.err
        }
    }
    return n, err
}

func (r *cmdReader) Close() error {
    return r.stdout.Close()
}

func runCmd(convCmd string, convArgs []string, inStream io.Reader) (io.ReadCloser, error) {
    var stderrBuf bytes.Buffer
    cmd := exec.Command(convCmd, convArgs...)
    
    stdin, err := cmd.StdinPipe()
    if err != nil {
        return nil, err
    }
    stdout, err := cmd.StdoutPipe()
    if err != nil {
        return nil, err
    }
    cmd.Stderr = &stderrBuf

    // 异步写入stdin
    go func() {
        defer stdin.Close()
        _, _ = io.Copy(stdin, inStream)
    }()

    if err := cmd.Start(); err != nil {
        return nil, err
    }

    return &cmdReader{
        stdout:    stdout,
        cmd:       cmd,
        stderrBuf: &stderrBuf,
    }, nil
}

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