Go语言中利用syscall.Kill高效中断子进程：信号控制机制详解

cmd := exec.Command("your_child_program")
err := cmd.Start()
if err != nil {
    // 处理错误
}
childPID := cmd.Process.Pid // 获取子进程PID

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
    "os/exec"
    "strings"
    "syscall" // 引入 syscall 包
    "time"
)

// checkInput 模拟从主程序的标准输入接收中断指令
func checkInput(msg chan string) {
    reader := bufio.NewReader(os.Stdin)
    fmt.Println("Type 'terminate' and press Enter to interrupt the child process.")
    for {
        line, err := reader.ReadString('\n')
        if err != nil {
            if err == io.EOF {
                fmt.Println("Master stdin closed.")
            } else {
                fmt.Printf("Error reading from master stdin: %v\n", err)
            }
            break
        }
        if strings.TrimSpace(line) == "terminate" {
            msg <- "terminate"
            return // 接收到终止指令后退出 Goroutine
        }
    }
}

func main() {
    fmt.Println("Master program started.")

    // 创建一个通道用于接收外部（例如用户输入）中断指令
    interruptSignal := make(chan string)
    go checkInput(interruptSignal) // 启动Goroutine监听主程序的stdin

    // 假设 child_process 是一个长时间运行的程序，例如 `sleep 100`
    // 在实际应用中，它可以是任何可执行文件，例如一个编译好的Go程序
    childCmd := exec.Command("sleep", "100") // 模拟一个100秒的子进程

    // 注意：如果子进程是一个自定义的Go程序，它需要实现信号捕获逻辑来优雅退出，例如：
    /*
    package main
    import (
        "fmt"
        "os"
        "os/signal"
        "syscall"
        "time"
    )
    func main() {
        c := make(chan os.Signal, 1)
        signal.Notify(c, syscall.SIGHUP, syscall.SIGTERM) // 捕获SIGHUP和SIGTERM
        fmt.Println("Child process started, PID:", os.Getpid())
        <-c // 等待信号
        fmt.Printf("Child process received signal. Terminating gracefully...\n")
        // 在这里执行清理工作，例如关闭文件、保存状态
        time.Sleep(2 * time.Second) // 模拟清理时间
        fmt.Println("Child process terminated.")
        os.Exit(0)
    }
    */

    err := childCmd.Start() // 启动子进程
    if err != nil {
        fmt.Printf("Failed to start child process: %v\n", err)
        return
    }

    childPID := childCmd.Process.Pid // 获取子进程的PID
    fmt.Printf("Child process started with PID: %d\n", childPID)

    loop:
        for i := 1; i <= 100; i++ {
            select {
            case <-interruptSignal:
                fmt.Println("\nMaster received 'terminate' signal.")
                fmt.Printf("Sending SIGTERM to child process (PID: %d)...\n", childPID)
                // 发送 SIGTERM 信号给子进程，请求其优雅终止
                // 也可以使用 syscall.SIGHUP 或在极端情况下使用 syscall.SIGKILL
                if err := syscall.Kill(childPID, syscall.SIGTERM); err != nil {
                    fmt.Printf("Error sending signal to child process: %v\n", err)
                }
                break loop // 退出进度更新循环
            case <-time.After(1 * time.Second):
                fmt.Printf("%d %% Complete\n", i) // 更新进度条
            }
            if i == 100 {
                fmt.Println("Child process running to completion without interruption.")
            }
        }

    fmt.Println("Waiting for child process to finish...")
    // 无论子进程是自然结束还是被信号中断，都应该调用 Wait() 来清理进程资源
    waitErr := childCmd.Wait()
    if waitErr != nil {
        // 检查子进程是否因信号而退出
        if exitError, ok := waitErr.(*exec.ExitError); ok {
            if status, ok := exitError.Sys().(syscall.WaitStatus); ok {
                if status.Signaled() {
                    fmt.Printf("Child process terminated by signal: %v\n", status.Signal())
                } else {
                    fmt.Printf("Child process exited with non-zero status: %v\n", status.ExitStatus())
                }
            } else {
                fmt.Printf("Child process exited with error: %v\n", exitError)
            }
        } else {
            fmt.Printf("Error waiting for child process: %v\n", waitErr)
        }
    } else {
        fmt.Println("Child process finished successfully.")
    }

    fmt.Println("Master program finished.")
}