Go语言中优雅地中断子进程：基于系统信号的实践

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
    "os/exec"
    "strconv"
    "strings"
    "time"
)

// checkInput 模拟一个用于监听标准输入的函数
func checkInput(msg chan string) {
    reader := bufio.NewReader(os.Stdin)
    for {
        line, err := reader.ReadString('\n')
        if err != nil {
            if err == io.EOF {
                fmt.Println("Stdin closed.")
            } else {
                fmt.Printf("Error reading from stdin: %v\n", err)
            }
            break
        }

        if strings.TrimSpace(line) == "terminate" {
            msg <- "terminate"
            return // 收到终止信号后退出
        }
    }
}

// 模拟一个长时间运行的子进程
// 这个子进程需要主动监听其stdin来接收"terminate"消息
func childProcessMain() {
    fmt.Println("Child process started, waiting for input...")
    reader := bufio.NewReader(os.Stdin)
    for i := 0; i < 100; i++ {
        select {
        case <-time.After(1 * time.Second):
            fmt.Printf("Child process working: %d%%\n", (i+1)*1)
        default:
            // 非阻塞地检查是否有输入
            if reader.Buffered() > 0 {
                line, err := reader.ReadString('\n')
                if err == nil && strings.TrimSpace(line) == "terminate" {
                    fmt.Println("Child process received 'terminate' via stdin. Exiting gracefully.")
                    return
                }
            }
        }
    }
    fmt.Println("Child process finished normally.")
}

func main() {
    // 为了演示，我们先将子进程的代码编译成一个可执行文件
    // 例如：go build -o child_process child_process.go
    // 假设 child_process 是编译后的子进程可执行文件
    // 在实际应用中，子进程可能是一个独立的程序

    // 启动子进程
    cmd := exec.Command("go", "run", "child_process_sim.go") // 假设子进程代码在 child_process_sim.go
    childStdin, err := cmd.StdinPipe()
    if err != nil {
        fmt.Printf("Failed to get stdin pipe: %v\n", err)
        return
    }
    defer childStdin.Close() // 确保管道关闭

    if err := cmd.Start(); err != nil {
        fmt.Printf("Failed to start child process: %v\n", err)
        return
    }
    fmt.Printf("Child process started with PID: %d\n", cmd.Process.Pid)

    message := make(chan string)
    go checkInput(message) // 在主程序中监听用户输入

    loop:
        for i := 1; i <= 100; i++ {
            select {
            case <-message:
                // 收到终止信号，向子进程的stdin写入 "terminate"
                fmt.Println("Master received terminate signal, sending to child.")
                _, writeErr := childStdin.Write([]byte("terminate\n"))
                if writeErr != nil {
                    fmt.Printf("Error writing to child stdin: %v\n", writeErr)
                }
                break loop
            case <-time.After(1 * time.Second):
                fmt.Printf("Master progress: %d %% Complete\n", i)
            }
        }

    // 等待子进程结束，无论是因为中断还是正常完成
    fmt.Println("Waiting for child process to finish...")
    err = cmd.Wait()
    if err != nil {
        fmt.Printf("Child process exited with error: %v\n", err)
    } else {
        fmt.Println("Child process finished successfully.")
    }
}

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    fmt.Printf("Child process (PID: %d) started, working...\n", os.Getpid())

    // 创建一个通道来接收系统信号
    sigChan := make(chan os.Signal, 1)
    // 注册要监听的信号：SIGINT 和 SIGTERM
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

    done := make(chan bool, 1)

    go func() {
        for i := 1; i <= 10; i++ { // 模拟10秒的工作
            select {
            case <-time.After(1 * time.Second):
                fmt.Printf("Child process working: %d%%\n", i*10)
            case <-sigChan:
                fmt.Println("Child process received termination signal. Cleaning up...")
                // 在这里执行清理工作，例如保存数据、关闭文件句柄等
                time.Sleep(2 * time.Second) // 模拟清理时间
                fmt.Println("Child process cleanup complete. Exiting.")
                done <- true
                return
            }
        }
        fmt.Println("Child process finished normally.")
        done <- true
    }()

    <-done // 等待工作完成或收到信号退出
    fmt.Println("Child process exiting main function.")
}

package main

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

func main() {
    // 启动子进程 (假设 child_process_sim.go 已经存在)
    cmd := exec.Command("go", "run", "child_process_sim.go")
    // 注意：这里不再需要 StdinPipe，因为我们通过信号通信

    if err := cmd.Start(); err != nil {
        fmt.Printf("Failed to start child process: %v\n", err)
        return
    }
    childPID := cmd.Process.Pid
    fmt.Printf("Master program started child process with PID: %d\n", childPID)

    // 模拟主程序的一些操作，并在5秒后发送终止信号
    for i := 1; i <= 5; i++ {
        fmt.Printf("Master program running: %d seconds\n", i)
        time.Sleep(1 * time.Second)
    }

    fmt.Printf("Master program sending SIGTERM to child process (PID: %d)...\n", childPID)
    // 发送 SIGTERM 信号
    // 注意：syscall.Kill 是 *nix 平台特有的
    err := syscall.Kill(syscall.Pid(childPID), syscall.SIGTERM)
    if err != nil {
        fmt.Printf("Failed to send SIGTERM to child process: %v\n", err)
        // 如果发送失败，可能子进程已经退出，或者权限不足
        // 可以尝试更强制的 SIGKILL，但应谨慎使用
        // fmt.Printf("Attempting to send SIGKILL to child process (PID: %d)...\n", childPID)
        // syscall.Kill(syscall.Pid(childPID), syscall.SIGKILL)
    }

    // 等待子进程结束
    fmt.Println("Master program waiting for child process to finish...")
    err = cmd.Wait()
    if err != nil {
        fmt.Printf("Child process exited with error: %v\n", err)
    } else {
        fmt.Println("Child process finished successfully (or was terminated gracefully).")
    }
}