Go 1.18中exec.Command搭配cmd.Process.Wait()偶尔无输出的问题排查及解决方案求助

你遇到的空输出问题，本质是竞态条件导致的：当你直接调用cmd.Process.Wait()时，绕过了exec.Cmd内置的IO同步机制。

exec.Cmd的Wait()方法做了两件事：

1. 等待操作系统层面的子进程终止；
2. 确保所有从子进程stdout/stderr到你指定缓冲区的IO拷贝操作完全完成。

而cmd.Process.Wait()只做第一件事——单纯等待子进程的终止信号。当子进程退出速度极快时，负责读取输出的goroutine可能还没来得及把所有数据写入buf，你的代码就已经返回了，这就导致了偶尔出现的空输出。

针对你的业务场景（需要启动后台进程，不能等待后台进程退出），这里提供几种可行的解决办法：

方案1：修正对cmd.Wait()的误解（优先推荐） #

首先纠正一个关键误解：对于service mysql start这类脚本，执行它的sh进程会在启动后台服务后立即退出，cmd.Wait()只会等待这个sh进程终止，不会等待后台的mysql进程。

所以你完全可以改用cmd.Wait()，这样既能保证输出被完全收集，又不会出现长时间等待的问题：

func ExecCommand(script string) ([]byte, error) {
    var buf bytes.Buffer
    cmd := exec.Command("sh", "-c", script)
    cmd.Stdout = &buf
    cmd.Stderr = &buf
    err := cmd.Start()
    if err != nil {
        return buf.Bytes(), err
    }
    err = cmd.Wait() // 改用cmd.Wait()替代Process.Wait()
    return buf.Bytes(), err
}

如果你的实际场景是直接启动前台运行的进程（比如无后台参数的mysql），只需修改脚本让进程后台运行（如mysql --daemonize或nohup mysql &），cmd.Wait()依然会正常返回。

方案2：手动同步IO读取（保留Process.Wait()） #

如果你确实需要保留cmd.Process.Wait()，可以手动启动goroutine读取子进程的输出，并用sync.WaitGroup确保所有输出写入缓冲区后再等待进程退出：

import (
    "bytes"
    "io"
    "os/exec"
    "sync"
)

func ExecCommand(script string) ([]byte, error) {
    var buf bytes.Buffer
    cmd := exec.Command("sh", "-c", script)
    
    // 创建管道获取子进程的stdout和stderr
    stdout, err := cmd.StdoutPipe()
    if err != nil {
        return nil, err
    }
    stderr, err := cmd.StderrPipe()
    if err != nil {
        return nil, err
    }
    
    err = cmd.Start()
    if err != nil {
        return nil, err
    }
    
    // 用WaitGroup等待所有IO读取完成
    var wg sync.WaitGroup
    wg.Add(2)
    
    go func() {
        defer wg.Done()
        _, _ = io.Copy(&buf, stdout)
    }()
    
    go func() {
        defer wg.Done()
        _, _ = io.Copy(&buf, stderr)
    }()
    
    // 等待所有输出被写入缓冲区
    wg.Wait()
    
    // 等待子进程退出
    _, err = cmd.Process.Wait()
    
    return buf.Bytes(), err
}

这种方式手动接管了IO读取逻辑，彻底避免了竞态条件导致的空输出问题。

方案3：分离子进程组（针对完全独立的后台进程） #

如果需要启动完全脱离父进程的后台服务，同时收集启动时的输出，可以设置进程组属性，确保后台进程不会随父进程退出而终止：

import (
    "bytes"
    "io"
    "os/exec"
    "sync"
    "syscall"
)

func ExecCommand(script string) ([]byte, error) {
    var buf bytes.Buffer
    cmd := exec.Command("sh", "-c", script)
    
    // 设置SysProcAttr，让子进程在新的进程组中运行
    cmd.SysProcAttr = &syscall.SysProcAttr{
        Setpgid: true,
    }
    
    stdout, err := cmd.StdoutPipe()
    if err != nil {
        return nil, err
    }
    stderr, err := cmd.StderrPipe()
    if err != nil {
        return nil, err
    }
    
    err = cmd.Start()
    if err != nil {
        return nil, err
    }
    
    var wg sync.WaitGroup
    wg.Add(2)
    go func() {
        defer wg.Done()
        io.Copy(&buf, stdout)
    }()
    go func() {
        defer wg.Done()
        io.Copy(&buf, stderr)
    }()
    wg.Wait()
    
    _, err = cmd.Process.Wait()
    return buf.Bytes(), err
}

这种方式既保证了启动输出被完全收集，又让后台进程可以独立运行。

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