Go语言中实现进程包装器与信号处理

package main

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

func main() {
    // 启动一个简单的子进程，例如 'sleep 5'
    cmd := exec.Command("sleep", "5")

    // 将子进程的输出重定向到当前进程的标准输出
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr

    fmt.Println("启动子进程...")
    err := cmd.Start()
    if err != nil {
        log.Fatalf("启动子进程失败: %v", err)
    }

    fmt.Printf("子进程已启动，PID: %d\n", cmd.Process.Pid)

    // 在后台等待子进程完成
    go func() {
        err := cmd.Wait()
        if err != nil {
            fmt.Printf("子进程退出，发生错误: %v\n", err)
        } else {
            fmt.Println("子进程正常退出。")
        }
    }()

    fmt.Println("主程序继续执行，等待5秒后子进程将退出...")
    time.Sleep(6 * time.Second) // 确保子进程有时间退出
}

package main

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

func main() {
    // 创建一个用于接收信号的channel
    sigc := make(chan os.Signal, 1)

    // 注册我们感兴趣的信号
    // 如果不指定信号，它将捕获所有可捕获的信号
    signal.Notify(sigc,
        syscall.SIGHUP,  // 挂断信号
        syscall.SIGINT,  // 中断信号 (Ctrl+C)
        syscall.SIGTERM, // 终止信号
        syscall.SIGQUIT, // 退出信号
    )

    fmt.Println("Go程序正在运行，等待信号...")

    // 在一个goroutine中处理接收到的信号
    go func() {
        s := <-sigc // 阻塞直到接收到信号
        fmt.Printf("接收到信号: %s\n", s.String())
        // 在这里执行清理工作或优雅关机逻辑
        fmt.Println("执行清理工作并退出...")
        os.Exit(0)
    }()

    // 主goroutine可以继续执行其他任务
    for i := 0; i < 10; i++ {
        fmt.Printf("主程序工作... %d\n", i)
        time.Sleep(1 * time.Second)
    }
    fmt.Println("主程序完成任务，等待信号处理或超时。")
    time.Sleep(5 * time.Second) // 等待信号处理
}

package main

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

func main() {
    // 1. 启动一个子进程，模拟一个需要被监控的服务
    // 这里使用一个简单的shell命令，它会等待SIGTERM信号
    // 注意：在实际应用中，子进程本身需要实现信号处理逻辑
    cmd := exec.Command("bash", "-c", "echo '子进程启动，PID: $$'; trap 'echo \"子进程收到SIGTERM，正在退出...\"; exit 0' SIGTERM; while true; do sleep 1; done")
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr

    fmt.Println("父进程：启动子进程...")
    err := cmd.Start()
    if err != nil {
        log.Fatalf("父进程：启动子进程失败: %v", err)
    }
    childProcess := cmd.Process
    fmt.Printf("父进程：子进程已启动，PID: %d\n", childProcess.Pid)

    // 2. 父进程自身注册信号处理，以便在父进程收到信号时也能处理
    parentSigc := make(chan os.Signal, 1)
    signal.Notify(parentSigc, syscall.SIGINT, syscall.SIGTERM)

    // 3. 在goroutine中处理父进程接收到的信号
    go func() {
        s := <-parentSigc
        fmt.Printf("父进程：接收到信号 %s，准备关闭子进程...\n", s.String())

        // 向子进程发送SIGTERM信号，请求其优雅关机
        if childProcess != nil {
            err := childProcess.Signal(syscall.SIGTERM)
            if err != nil {
                fmt.Printf("父进程：向子进程发送SIGTERM失败: %v\n", err)
            } else {
                fmt.Println("父进程：已向子进程发送SIGTERM。")
            }
        }

        // 等待子进程退出，或设置一个超时
        select {
        case <-time.After(5 * time.Second):
            fmt.Println("父进程：等待子进程退出超时，强制终止。")
            if childProcess != nil {
                _ = childProcess.Kill() // 强制终止
            }
        case <-time.After(1 * time.Second): // 等待子进程信号处理
            // 检查子进程是否已退出
            if childProcess != nil {
                _, err := childProcess.Wait()
                if err != nil && err.Error() == "wait: no child processes" {
                    fmt.Println("父进程：子进程已退出。")
                } else if err != nil {
                    fmt.Printf("父进程：子进程退出，错误: %v\n", err)
                } else {
                    fmt.Println("父进程：子进程优雅退出。")
                }
            }
        }
        os.Exit(0)
    }()

    // 4. 监控子进程的退出
    go func() {
        err := cmd.Wait() // 阻塞直到子进程退出
        if err != nil {
            fmt.Printf("父进程：子进程退出，发生错误: %v\n", err)
        } else {
            fmt.Println("父进程：子进程正常退出。")
        }
    }()

    fmt.Println("父进程：主循环运行中，等待信号...")
    select {} // 阻塞主goroutine，直到程序被信号终止
}