Go语言中正确终止子进程：使用进程组管理

package main

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

// runCommandWithTimeout 演示如何在Go中启动一个命令并处理其超时终止，包括子进程。
func runCommandWithTimeout(command string, args ...string) error {
    var output bytes.Buffer
    cmd := exec.Command(command, args...)
    // 注意：实际应用中，srcFile和Dir需要根据具体情况设置
    // 为了示例运行，这里简化Dir的设置
    cmd.Dir = "." // 假设在当前目录运行
    cmd.Stdout = &output
    cmd.Stderr = &output

    // 关键步骤：设置命令成为一个新的进程组的组长
    // 这样，我们可以通过进程组ID来终止整个进程树
    cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}

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

    // 使用一个channel来接收命令完成信号
    done := make(chan error, 1)
    go func() {
        done <- cmd.Wait() // 等待命令完成
    }()

    // 设置一个定时器，在2秒后触发终止操作
    select {
    case err := <-done:
        // 命令在超时前完成
        if err != nil {
            fmt.Printf("Command finished with error: %v\n", err)
        } else {
            fmt.Printf("Command finished successfully.\n")
        }
    case <-time.After(time.Second * 2):
        // 超时，需要终止进程组
        fmt.Printf("Timeout: Attempting to kill process group...\n")
        pgid, err := syscall.Getpgid(cmd.Process.Pid)
        if err != nil {
            fmt.Printf("Error getting process group ID: %v\n", err)
            // 尝试杀死单个进程作为回退
            if cmd.Process != nil {
                if killErr := cmd.Process.Signal(syscall.SIGKILL); killErr != nil {
                    fmt.Printf("Error killing individual process: %v\n", killErr)
                }
            }
        } else {
            // 向整个进程组发送SIGKILL信号
            // 注意负号，表示发送给进程组
            if killErr := syscall.Kill(-pgid, syscall.SIGKILL); killErr != nil {
                fmt.Printf("Error killing process group (PGID: %d): %v\n", pgid, killErr)
            } else {
                fmt.Printf("Successfully sent SIGKILL to process group %d.\n", pgid)
            }
        }

        // 再次等待命令，以确保它被清理
        // 否则，即使发送了信号，如果未Wait()，资源可能不会完全释放
        if err := <-done; err != nil {
            fmt.Printf("Command (after kill) finished with error: %v\n", err)
        } else {
            fmt.Printf("Command (after kill) finished successfully (or was already terminated).\n")
        }
    }

    fmt.Printf("Command output:\n%s\n", output.String())
    return nil
}

func main() {
    fmt.Println("Running 'sleep 5' with 2 second timeout...")
    // 模拟一个会超时并可能产生子进程的命令
    // 在Linux/macOS上，`sleep`命令不会产生子进程，但作为演示超时终止的例子
    // 对于会产生子进程的复杂命令，此方法更为关键
    err := runCommandWithTimeout("sleep", "5")
    if err != nil {
        fmt.Printf("runCommandWithTimeout returned error: %v\n", err)
    }
    fmt.Println("---")

    fmt.Println("Running 'echo Hello' (should finish quickly)...")
    err = runCommandWithTimeout("echo", "Hello")
    if err != nil {
        fmt.Printf("runCommandWithTimeout returned error: %v\n", err)
    }
    fmt.Println("---")

    // 假设一个会产生子进程的命令，例如一个脚本
    // func.sh 内容:
    // #!/bin/bash
    // echo "Parent process running..."
    // sleep 10 & # 后台运行一个子进程
    // CHILD_PID=$!
    // echo "Child process $CHILD_PID started."
    // sleep 5 # 父进程等待
    // echo "Parent process exiting."
    // exit 0
    // 编译并运行此Go程序时，需要确保func.sh存在且可执行
    // fmt.Println("Running 'func.sh' with 2 second timeout...")
    // err = runCommandWithTimeout("./func.sh")
    // if err != nil {
    //  fmt.Printf("runCommandWithTimeout returned error: %v\n", err)
    // }
    // fmt.Println("---")
}