我的问题是，当上下文超时时，子sleep进程没有被杀死。父进程sh被杀死，但子进程sleep被保留。
这通常仍然允许cmd.Wait()调用成功，但问题是cmd.Wait()等待进程退出 * 和 * 复制输出。因为我们已经分配了cmd.Stdout，所以我们必须等待sleep进程的stdout管道的读端关闭，但它永远不会关闭，因为进程仍在运行。
为了杀死子进程，我们可以通过设置Setpgid位来启动进程作为自己的进程组领导者，这将允许我们使用其 negative PID杀死进程以及任何子进程。
下面是我提出的exec.CommandContext的替代品，它可以做到这一点：

type Cmd struct {
    ctx context.Context
    terminated chan struct{}
    *exec.Cmd
}

// NewCommand is like exec.CommandContext but ensures that subprocesses
// are killed when the context times out, not just the top level process.
func NewCommand(ctx context.Context, command string, args ...string) *Cmd {
    return &Cmd{
        ctx:        ctx,
        terminated: make(chan struct{}),
        Cmd:        exec.Command(command, args...),
    }
}

func (c *Cmd) Start() error {
    // Force-enable setpgid bit so that we can kill child processes when the
    // context times out or is canceled.
    if c.Cmd.SysProcAttr == nil {
        c.Cmd.SysProcAttr = &syscall.SysProcAttr{}
    }
    c.Cmd.SysProcAttr.Setpgid = true
    err := c.Cmd.Start()
    if err != nil {
        return err
    }
    go func() {
        select {
        case <-c.terminated:
            return
        case <-c.ctx.Done():
        }
        p := c.Cmd.Process
        if p == nil {
            return
        }
        // Kill by negative PID to kill the process group, which includes
        // the top-level process we spawned as well as any subprocesses
        // it spawned.
        _ = syscall.Kill(-p.Pid, syscall.SIGKILL)
    }()
    return nil
}

func (c *Cmd) Run() error {
    if err := c.Start(); err != nil {
        return err
    }
    return c.Wait()
}

func (c *Cmd) Wait() error {
    defer close(c.terminated)
    return c.Cmd.Wait()
}

• 更新-
  自从编写这段代码以来，我遇到过这样的情况，子进程有时想加入自己的进程组，而setpgid技巧不再起作用，因为它不会杀死那些新进程组中的进程。更健壮的解决方案可能是使用类似go-ps的东西手动遍历进程树，并为每个后代进程使用以下伪代码：

// KillProcessTree kills an entire process tree using SIGKILL.
func KillProcessTree(pid int) error {
  // Send SIGSTOP to prevent new children from being spawned
  _ = syscall.Signal(pid, syscall.SIGSTOP)
  // TODO: implement ChildProcesses
  for _, c := range ChildProcesses(pid) {
    _ = KillProcessTree(c.Pid)
  }
  // Now that the process is stopped and all descendants
  // are guaranteed to be killed, we can safely SIGKILL
  // this process, without worrying about descendant
  // processes being reparented to pid 1 or anything
  // like that.
  _ = syscall.Signal(pid, syscall.SIGKILL)
  return nil // TODO: better error handling :)
}