Go语言中安全终止子进程的策略与跨平台考量

package main

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

func main() {
    // 创建一个模拟长时间运行的脚本
    createDummyScript()

    var output bytes.Buffer
    // 假设 "long_running_script.sh" 会创建子进程并长时间运行
    cmd := exec.Command("bash", "long_running_script.sh")
    cmd.Dir = "." // 在当前目录执行
    cmd.Stdout = &output
    cmd.Stderr = &output

    // 关键设置：将子进程放入独立的进程组
    cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}

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

    fmt.Printf("Command started with PID: %d\n", cmd.Process.Pid)

    // 设置一个定时器，在2秒后尝试终止进程组
    timer := time.AfterFunc(time.Second*2, func() {
        fmt.Printf("\nTimeout reached. Attempting to kill process group...\n")

        pgid, err := syscall.Getpgid(cmd.Process.Pid)
        if err != nil {
            fmt.Printf("Error getting process group ID: %s\n", err)
            return
        }

        // 向整个进程组发送 SIGTERM 信号
        // 注意：负号 -pgid 表示向进程组发送信号
        if err := syscall.Kill(-pgid, syscall.SIGTERM); err != nil {
            fmt.Printf("Error sending SIGTERM to process group %d: %s\n", pgid, err)
            // 如果 SIGTERM 失败，可以尝试 SIGKILL
            if err := syscall.Kill(-pgid, syscall.SIGKILL); err != nil {
                fmt.Printf("Error sending SIGKILL to process group %d: %s\n", pgid, err)
            }
        }
        fmt.Printf("Signal sent to process group %d.\n", pgid)
    })
    defer timer.Stop() // 确保在 cmd.Wait() 正常返回时停止定时器

    // 等待命令完成
    err := cmd.Wait()
    if err != nil {
        fmt.Printf("Command finished with error: %s\n", err)
    } else {
        fmt.Printf("Command finished successfully.\n")
    }
    fmt.Printf("Done waiting. Output:\n%s\n", output.String())

    // 清理模拟脚本
    os.Remove("long_running_script.sh")
}

// createDummyScript 创建一个模拟的 shell 脚本，该脚本会启动一个子进程并长时间运行
func createDummyScript() {
    scriptContent := `#!/bin/bash
echo "Parent script started (PID: $$)"
# 启动一个后台子进程
(
    echo "Child process started (PID: $$)"
    sleep 100 # 模拟长时间运行
    echo "Child process finished"
) &
CHILD_PID=$!
echo "Child process launched with PID: $CHILD_PID"
wait $CHILD_PID # 等待子进程完成，这样父进程不会直接退出
echo "Parent script finished"
`
    err := os.WriteFile("long_running_script.sh", []byte(scriptContent), 0755)
    if err != nil {
        fmt.Printf("Error creating dummy script: %s\n", err)
        os.Exit(1)
    }
}