Go语言中正确终止子进程及其进程组的方法

func() {
    var output bytes.Buffer
    cmd := exec.Command("Command", args...)
    cmd.Dir = filepath.Dir(srcFile)
    cmd.Stdout, cmd.Stderr = &output, &output
    if err := cmd.Start(); err != nil {
        return err
    }
    defer time.AfterFunc(time.Second*2, func() {
        fmt.Printf("Nobody got time fo that\n")
        if err := cmd.Process.Signal(syscall.SIGKILL); err != nil {
            fmt.Printf("Error:%s\n", err)
        }
        fmt.Printf("It's dead Jim\n")
    }).Stop()
    err := cmd.Wait()
    fmt.Printf("Done waiting\n")
}()

package main

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

func main() {
    // 1. 模拟一个会长时间运行或派生子进程的命令
    // 为了演示，我们创建一个简单的bash脚本，它会打印PID并睡眠很长时间。
    // 在实际应用中，这里可以是 "go test html" 或其他复杂命令。
    scriptContent := `#!/bin/bash
echo "Child process started with PID $$"
sleep 1000 # 模拟一个长时间运行的进程
`
    // 创建一个临时脚本文件
    tmpfile, err := os.CreateTemp("", "long_run_script_*.sh")
    if err != nil {
        fmt.Println("Error creating temp file:", err)
        return
    }
    defer os.Remove(tmpfile.Name()) // 确保在程序结束时清理临时文件
    tmpfile.WriteString(scriptContent)
    tmpfile.Close()
    os.Chmod(tmpfile.Name(), 0755) // 使脚本可执行

    // 2. 准备执行命令
    cmd := exec.Command(tmpfile.Name()) // 使用临时脚本作为要执行的命令
    // cmd := exec.Command("go", "test", "html") // 如果需要测试go test，可以替换此处

    var output bytes.Buffer
    cmd.Stdout = &output
    cmd.Stderr = &output

    // 3. 关键：将子进程放入独立的进程组
    // 必须在 cmd.Start() 之前设置 SysProcAttr
    cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}

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

    // 4. 设置一个超时器，在指定时间后尝试终止进程组
    // 这里我们设置5秒超时
    timer := time.AfterFunc(time.Second*5, func() {
        fmt.Printf("\nTimeout reached for PID %d. Attempting to kill process group...\n", cmd.Process.Pid)
        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
        }
        // 向整个进程组发送SIGKILL信号
        // 注意：负号表示向进程组发送信号，而不是单个进程
        if err := syscall.Kill(-pgid, syscall.SIGKILL); err != nil {
            fmt.Printf("Error killing process group %d (leader PID %d): %v\n", pgid, cmd.Process.Pid, err)
        } else {
            fmt.Printf("Successfully sent SIGKILL to process group %d (leader PID %d).\n", pgid, cmd.Process.Pid)
        }
    })
    defer timer.Stop() // 确保在 cmd.Wait() 完成时停止计时器，防止不必要的执行

    fmt.Printf("Command started with PID %d. Waiting for it to finish or timeout...\n", cmd.Process.Pid)

    // 5. 等待命令完成
    err = cmd.Wait()
    if err != nil {
        // 如果进程被信号终止，Wait()通常会返回一个 *exec.ExitError
        if exitError, ok := err.(*exec.ExitError); ok {
            // 在Unix-like系统上，被信号终止的进程其ExitCode通常为-1，但Signal字段会包含终止信号
            fmt.Printf("Command finished with error: %v (Exit code: %d, Signal: %v)\n", exitError, exitError.ExitCode(), exitError.Signal())
        } else {
            fmt.Printf("Command finished with unexpected error: %v\n", err)
        }
    } else {
        fmt.Println("Command finished successfully (should not happen in this timeout scenario).")
    }
    fmt.Println("Output from command:\n", output.String())
    fmt.Println("Done waiting for command.")
}