Golang进程控制与信号处理：构建健壮的进程包装器

package main

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

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

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

    fmt.Printf("启动命令: %s %v\n", cmd.Path, cmd.Args)

    err := cmd.Start() // 异步启动命令
    if err != nil {
        fmt.Printf("启动命令失败: %v\n", err)
        return
    }

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

    // 等待命令完成
    err = cmd.Wait()
    if err != nil {
        fmt.Printf("命令执行完成，但出现错误: %v\n", err)
    } else {
        fmt.Println("命令执行成功。")
    }

    fmt.Println("主程序退出。")
}

package main

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

func main() {
    // 创建一个通道，用于接收系统信号
    sigc := make(chan os.Signal, 1)

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

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

    // 在一个goroutine中处理接收到的信号
    go func() {
        s := <-sigc // 阻塞直到接收到一个信号
        fmt.Printf("接收到信号: %s\n", s.String())

        // 根据接收到的信号执行相应的清理或退出逻辑
        switch s {
        case syscall.SIGINT, syscall.SIGTERM:
            fmt.Println("收到终止信号，准备优雅退出...")
            // 执行清理工作，例如关闭数据库连接、保存状态等
            time.Sleep(2 * time.Second) // 模拟清理工作
            os.Exit(0)
        case syscall.SIGHUP:
            fmt.Println("收到HUP信号，重新加载配置...")
            // 执行配置重载逻辑
        default:
            fmt.Printf("收到未处理的信号: %s\n", s.String())
        }
    }()

    // 主goroutine继续执行其他任务，或保持阻塞
    select {} // 阻塞主goroutine，直到程序被信号处理函数退出
}

package main

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

func main() {
    // 1. 启动子进程
    childCmd := exec.Command("sh", "-c", "echo '子进程启动'; sleep 10; echo '子进程退出'")
    childCmd.Stdout = os.Stdout
    childCmd.Stderr = os.Stderr

    err := childCmd.Start()
    if err != nil {
        fmt.Printf("启动子进程失败: %v\n", err)
        return
    }
    fmt.Printf("子进程已启动，PID: %d\n", childCmd.Process.Pid)

    // 2. 注册信号处理器，捕获发送给当前包装器的信号
    sigc := make(chan os.Signal, 1)
    signal.Notify(sigc, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)

    // 3. 在一个goroutine中等待子进程结束
    childDone := make(chan error, 1)
    go func() {
        childDone <- childCmd.Wait() // 阻塞直到子进程退出
    }()

    // 4. 主循环处理信号或等待子进程
    for {
        select {
        case s := <-sigc: // 捕获发送给包装器的信号
            fmt.Printf("包装器收到信号: %s\n", s.String())
            switch s {
            case syscall.SIGINT, syscall.SIGTERM:
                fmt.Println("包装器收到终止信号，向子进程发送SIGTERM...")
                // 向子进程发送SIGTERM
                if childCmd.Process != nil {
                    err := childCmd.Process.Signal(syscall.SIGTERM)
                    if err != nil {
                        fmt.Printf("向子进程发送SIGTERM失败: %v\n", err)
                    }
                }
                // 给子进程一些时间来优雅退出
                select {
                case <-time.After(5 * time.Second):
                    fmt.Println("子进程未在规定时间内退出，强制杀死...")
                    if childCmd.Process != nil {
                        childCmd.Process.Kill() // 强制杀死
                    }
                case <-childDone:
                    fmt.Println("子进程已优雅退出。")
                }
                fmt.Println("包装器退出。")
                os.Exit(0)
            case syscall.SIGHUP:
                fmt.Println("包装器收到HUP信号，重新加载配置或通知子进程...")
                // 可以选择向子进程发送SIGHUP或执行其他操作
            }
        case err := <-childDone: // 子进程退出
            if err != nil {
                fmt.Printf("子进程异常退出: %v\n", err)
            } else {
                fmt.Println("子进程正常退出。")
            }
            fmt.Println("包装器退出。")
            os.Exit(0) // 子进程退出后，包装器也退出
        }
    }
}