Go程序中启动并等待守护化子进程的最佳实践

父进程A:
|
|`-- 调用 exec.Command("子进程B").Run()
|
|    子进程B:
|    |
|    |`-- 执行守护化操作（例如：fork出守护进程C，设置会话ID等）
|    |
|     `-- 子进程B 退出
|
`-- exec.Command("子进程B").Run() 完成，父进程A继续执行

package main

import (
    "fmt"
    "log"
    "net"
    "os"
    "time"
)

const healthPort = ":8081" // 用于健康检查的端口

func main() {
    // 记录守护进程的PID，便于观察
    log.Printf("Actual Daemon (PID %d) started. Running indefinitely...\n", os.Getpid())

    // 启动一个Goroutine作为健康检查服务器
    go func() {
        listener, err := net.Listen("tcp", healthPort)
        if err != nil {
            log.Printf("Health check listener error: %v", err)
            return
        }
        defer listener.Close()
        log.Printf("Health check server listening on %s", healthPort)

        for {
            conn, err := listener.Accept()
            if err != nil {
                log.Printf("Health check accept error: %v", err)
                continue
            }
            fmt.Fprintf(conn, "OK\n") // 收到请求时回复"OK"
            conn.Close()
        }
    }()

    // 守护进程的主逻辑，模拟长时间运行
    for {
        time.Sleep(5 * time.Second)
        log.Printf("Daemon (PID %d) still alive at %s\n", os.Getpid(), time.Now().Format("15:04:05"))
    }
}

package main

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

func main() {
    log.Println("Daemon Launcher process started.")

    // 构建实际守护进程的命令
    cmd := exec.Command("./actual_daemon") // 假设actual_daemon可执行文件在当前目录

    // 重定向标准输入、输出和错误到/dev/null，这是守护进程的常见做法
    cmd.Stdin = nil
    cmd.Stdout = nil
    cmd.Stderr = nil

    // 设置SysProcAttr以实现守护化：
    // Setsid: true 会使进程成为新的会话领导者，并脱离控制终端。
    cmd.SysProcAttr = &syscall.SysProcAttr{
        Setsid: true,
    }

    err := cmd.Start() // 启动实际的守护进程
    if err != nil {
        log.Printf("Error starting actual daemon: %v\n", err)
        os.Exit(1)
    }

    log.Printf("Actual Daemon (PID %d) launched by launcher (PID %d). Launcher exiting.\n", cmd.Process.Pid, os.Getpid())
    time.Sleep(500 * time.Millisecond) // 给予守护进程一点时间来完全脱离
    os.Exit(0)                         // 启动器进程退出，这正是父进程main.go所等待的
}

package main

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

const daemonHealthPort = ":8081" // 守护进程的健康检查端口

func main() {
    log.Println("Parent process started. Launching daemonizer...")

    // 确保 daemon_launcher 可执行文件存在
    // 在实际场景中，您需要先构建它们。
    // 这里假设它们已构建并在当前目录。

    cmd := exec.Command("./daemon_launcher") // 启动守护进程启动器
    // 可以选择重定向启动器的输出，以便调试
    // cmd.Stdout = os.Stdout
    // cmd.Stderr = os.Stderr

    // 使用 cmd.Run() 等待 daemon_launcher 退出
    err := cmd.Run()
    if err != nil {
        log.Printf("Error running daemon launcher: %v\n", err)
        os.Exit(1)
    }

    log.Println("Daemon launcher exited. Daemonization process completed.")
    log.Println("Parent process can now continue or exit, daemon should be running independently.")

    // 尝试检查守护进程的健康状态
    log.Println("Attempting to check daemon health...")
    for i := 0; i < 5; i++ { // 尝试几次，给守护进程启动时间
        conn, err := net.DialTimeout("tcp", "localhost"+daemonHealthPort, 1*time.Second)
        if err == nil {
            fmt.Println("Daemon health check successful! Daemon is responsive.")
            conn.Close()
            break
        }
        log.Printf("Daemon not yet responsive, retrying... (%v)\n", err)
        time.Sleep(1 * time.Second)
        if i == 4 {
            log.Println("Failed to connect to daemon after multiple retries.")
        }
    }

    // 父进程继续执行其他任务或退出
    time.Sleep(10 * time.Second) // 观察守护进程的输出
    log.Println("Parent process finished.")
}