Go语言进程管理：优雅地终止子进程组

package main

import (
    "bytes"
    "fmt"
    "os/exec"
    "syscall"
    "time"
)

func runProblematicCommand() {
    var output bytes.Buffer
    // 假设 "Command" 是一个会长时间运行或产生子进程的命令
    cmd := exec.Command("bash", "-c", "sleep 10 && echo 'Done sleeping'")
    cmd.Stdout, cmd.Stderr = &output, &output

    if err := cmd.Start(); err != nil {
        fmt.Printf("Error starting command: %v\n", err)
        return
    }

    // 设置一个2秒的超时，尝试杀死进程
    timer := time.AfterFunc(time.Second*2, func() {
        fmt.Printf("Nobody got time for that - timeout triggered!\n")
        // 尝试发送SIGKILL给父进程
        if err := cmd.Process.Signal(syscall.SIGKILL); err != nil {
            fmt.Printf("Error sending SIGKILL: %s\n", err)
        }
        fmt.Printf("It's dead Jim (or so we thought)\n")
    })
    defer timer.Stop() // 确保计时器在cmd.Wait()完成时停止

    err := cmd.Wait() // 等待命令完成或被杀死
    fmt.Printf("Done waiting for command, error: %v\n", err)
    fmt.Printf("Command output:\n%s\n", output.String())
}

// func main() {
//  runProblematicCommand()
// }

package main

import (
    "bytes"
    "context"
    "fmt"
    "os/exec"
    "syscall"
    "time"
)

// runCommandWithTimeout executes a command with a timeout,
// ensuring child processes are also terminated on Unix-like systems.
func runCommandWithTimeout(command string, args []string, timeout time.Duration) error {
    var output bytes.Buffer
    // 使用context.WithTimeout管理超时
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel() // 确保在函数退出时取消上下文，释放资源

    cmd := exec.CommandContext(ctx, command, args...)
    cmd.Stdout = &output
    cmd.Stderr = &output
    // 关键设置：为新进程创建独立的进程组
    cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}

    fmt.Printf("Starting command: %s %v with timeout %v\n", command, args, timeout)
    if err := cmd.Start(); err != nil {
        fmt.Printf("Error starting command: %v\n", err)
        return err
    }

    // 启动一个goroutine来监听上下文的取消事件（包括超时）
    go func() {
        <-ctx.Done() // 等待上下文被取消或超时
        if ctx.Err() == context.DeadlineExceeded {
            fmt.Printf("Command timed out after %v. Attempting to terminate process group...\n", timeout)
            // 获取进程组ID
            pgid, err := syscall.Getpgid(cmd.Process.Pid)
            if err != nil {
                fmt.Printf("Error getting process group ID for PID %d: %v\n", cmd.Process.Pid, err)
                return
            }

            // 首先发送SIGTERM给整个进程组，尝试优雅终止
            fmt.Printf("Sending SIGTERM to process group %d\n", pgid)
            if err := syscall.Kill(-pgid, syscall.SIGTERM); err != nil {
                fmt.Printf("Error sending SIGTERM to process group %d: %v\n", pgid, err)
            }

            // 给予进程组一些时间来优雅终止，如果仍然未退出，则发送SIGKILL强制终止
            go func() {
                select {
                case <-time.After(time.Second * 3): // 等待3秒
                    // 检查进程是否已经退出
                    if cmd.ProcessState == nil || !cmd.ProcessState.Exited() {
                        fmt.Printf("Process group %d did not terminate after SIGTERM. Sending SIGKILL...\n", pgid)
                        if err := syscall.Kill(-pgid, syscall.SIGKILL); err != nil {
                            fmt.Printf("Error sending SIGKILL to process group %d: %v\n", pgid, err)
                        }
                    }
                case <-ctx.Done(): // 如果主上下文已经完成（例如cmd.Wait()已经返回）
                    return
                }
            }()
        }
    }()

    // 等待命令完成或被杀死
    err := cmd.Wait()
    fmt.Printf("Command finished with error: %v\n", err)
    fmt.Printf("Command output:\n%s\n", output.String())

    if err != nil {
        if exitErr, ok := err.(*exec.ExitError); ok {
            // 检查是否是由于超时而终止
            if ctx.Err() == context.DeadlineExceeded {
                fmt.Printf("Command explicitly timed out and was terminated.\n")
                return fmt.Errorf("command timed out and was terminated: %w", err)
            }
            return fmt.Errorf("command exited with error: %w", err)
        }
        return fmt.Errorf("command wait error: %w", err)
    }
    fmt.Printf("Command completed successfully.\n")
    return nil
}

func main() {
    fmt.Println("\n--- Test Case 1: Short-running command (expected success) ---")
    err := runCommandWithTimeout("bash", []