如何在Golang中实现类似Caddy的命令模式后台运行功能？

package main

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

const pidFile = "pidfile"

func main() {
    if len(os.Args) < 2 {
        fmt.Println("Usage: ./program start|stop|reload")
        return
    }

    command := os.Args[1]
    switch command {
    case "start":
        start()
    case "stop":
        stop()
    case "reload":
        reload()
    default:
        fmt.Println("Invalid command:", command)
    }
}

func start() {
    cmd := exec.Command(os.Args[0], "run")
    err := cmd.Start()
    if err != nil {
        fmt.Println("Failed to start:", err)
        return
    }
    pid := strconv.Itoa(cmd.Process.Pid)
    err = os.WriteFile(pidFile, []byte(pid), 0644)
    if err != nil {
        fmt.Println("Failed to write PID to file:", err)
        return
    }
    fmt.Println("Started successfully. PID:", pid)
}

func stop() {
    pid, err := readPID()
    if err != nil {
        fmt.Println("Failed to read PID:", err)
        return
    }
    process, err := os.FindProcess(pid)
    if err != nil {
        fmt.Println("Failed to find process:", err)
        return
    }
    err = process.Signal(syscall.SIGTERM)
    if err != nil {
        fmt.Println("Failed to send SIGTERM:", err)
        return
    }
    fmt.Println("Stop signal sent. PID:", pid)
    os.Remove(pidFile) //remove pid file after stop
}

func reload() {
    pid, err := readPID()
    if err != nil {
        fmt.Println("Failed to read PID:", err)
        return
    }
    process, err := os.FindProcess(pid)
    if err != nil {
        fmt.Println("Failed to find process:", err)
        return
    }
    err = process.Signal(syscall.SIGHUP)
    if err != nil {
        fmt.Println("Failed to send SIGHUP:", err)
        return
    }
    fmt.Println("Reload signal sent. PID:", pid)
}

func readPID() (int, error) {
    data, err := os.ReadFile(pidFile)
    if err != nil {
        return 0, err
    }
    pid, err := strconv.Atoi(string(data))
    if err != nil {
        return 0, err
    }
    return pid, nil
}

func run() {
    fmt.Println("Running...")
    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGTERM, syscall.SIGHUP)
    for {
        select {
        case s := <-sigChan:
            switch s {
            case syscall.SIGTERM:
                fmt.Println("Received SIGTERM, shutting down...")
                return
            case syscall.SIGHUP:
                fmt.Println("Received SIGHUP, reloading...")
                // Add your reload logic here
            }
        }
    }
}