如何让Shell脚本触发的Go应用实现自我更新与自动重启？

针对你的Go应用A的自我更新与重启需求，结合Linux环境和Shell脚本S的启动场景，提供以下几个自给自足的实现方案：

方案1：进程替换（最优解，无额外资源占用） #

利用Linux的exec系统调用直接替换当前进程，保持PID不变，让脚本S全程等待进程完成，同时避免子进程资源占用。

实现步骤 #

1. 使用go-selfupdate完成二进制更新后，获取更新后的可执行文件路径。
2. 通过syscall.Exec用新二进制替换当前进程，同时传递标记参数避免重复触发更新。
3. 新进程启动后，根据标记跳过更新流程，直接执行下载解压等核心任务。

代码示例 #

import (
    "log"
    "os"
    "syscall"
    "flag"
)

func main() {
    skipUpdate := flag.Bool("skip-update", false, "跳过自我更新流程")
    flag.Parse()

    if !*skipUpdate {
        // 执行自我更新逻辑（调用go-selfupdate）
        updated, err := performSelfUpdate()
        if err != nil {
            log.Fatalf("自我更新失败: %v", err)
        }
        if updated {
            // 更新完成，替换当前进程为新二进制
            newBinaryPath := "./A" // 假设go-selfupdate已覆盖原文件
            // 构造新进程参数，添加--skip-update标记
            args := append([]string{os.Args[0]}, os.Args[1:]...)
            args = append(args, "--skip-update")
            
            // 执行进程替换
            err := syscall.Exec(newBinaryPath, args, os.Environ())
            if err != nil {
                log.Fatalf("进程替换失败: %v", err)
            }
            // 替换成功后，原进程会立即终止，不会执行后续代码
        }
    }

    // 执行核心任务：下载并解压文件
    performDownloadAndExtract()
}

// 模拟自我更新函数
func performSelfUpdate() (bool, error) {
    // 此处调用go-selfupdate的逻辑，返回是否完成更新
    return true, nil
}

// 模拟下载解压函数
func performDownloadAndExtract() {
    log.Println("执行下载解压任务...")
    // 任务逻辑
}

优势 #

• 无额外进程创建，资源占用最低；
• 脚本S会持续等待该进程（PID未变），直到任务完成；
• 完全内置在A中，无需修改脚本S的核心逻辑。

方案2：父进程监听子进程信号（兼容原有更新逻辑） #

如果无法使用进程替换，可让原进程启动新进程后，通过信号监听提前释放资源，同时保证脚本S等待到任务完成。

实现步骤 #

1. 原进程完成更新后，启动新进程并添加--post-update标记；
2. 原进程监听新进程发送的SIGUSR1信号，收到后立即退出；
3. 新进程完成核心任务后，向父进程发送信号，随后自行退出。

代码示例 #

import (
    "log"
    "os"
    "os/exec"
    "syscall"
    "flag"
    "signal"
)

func main() {
    postUpdate := flag.Bool("post-update", false, "更新后执行核心任务模式")
    flag.Parse()

    if *postUpdate {
        // 执行核心任务
        performDownloadAndExtract()
        // 向父进程发送完成信号
        ppid := os.Getppid()
        if parentProc, err := os.FindProcess(ppid); err == nil {
            _ = parentProc.Signal(syscall.SIGUSR1)
        }
        os.Exit(0)
    }

    // 执行自我更新
    updated, err := performSelfUpdate()
    if err != nil {
        log.Fatalf("自我更新失败: %v", err)
    }
    if updated {
        // 启动新进程
        cmd := exec.Command("./A", "--post-update")
        cmd.Stdout = os.Stdout
        cmd.Stderr = os.Stderr
        if err := cmd.Start(); err != nil {
            log.Fatalf("启动新进程失败: %v", err)
        }

        // 监听子进程的完成信号
        sigChan := make(chan os.Signal, 1)
        signal.Notify(sigChan, syscall.SIGUSR1)
        go func() {
            <-sigChan
            // 释放父进程对子进程的资源持有，提前退出
            _ = cmd.Process.Release()
            os.Exit(0)
        }()

        // 兜底等待，防止信号丢失
        if err := cmd.Wait(); err != nil {
            log.Printf("子进程退出异常: %v", err)
        }
        os.Exit(0)
    }

    // 未更新时直接执行任务
    performDownloadAndExtract()
}

优势 #

• 无需修改脚本S；
• 父进程在收到信号后立即释放资源，避免长期占用；
• 脚本S会等待到父进程退出，而父进程会确保子进程完成任务。

方案3：脚本层循环重启（最小代码改动） #

通过给脚本S添加简单的循环逻辑，基于A的退出码判断是否需要重启，无需在A中处理进程启动逻辑。

实现步骤 #

1. 在A中，完成自我更新后返回特定退出码（比如2）；
2. 修改脚本S，循环执行A，直到退出码不是重启标记。

脚本S示例 #

#!/bin/bash
while true; do
    ./A
    EXIT_CODE=$?
    # 退出码2表示需要重启，其他情况终止循环
    if [ $EXIT_CODE -ne 2 ]; then
        exit $EXIT_CODE
    fi
    # 可选：添加短暂延迟，避免频繁重启
    sleep 1
done

A中更新逻辑示例 #

func main() {
    // 执行自我更新
    updated, err := performSelfUpdate()
    if err != nil {
        log.Fatalf("自我更新失败: %v", err)
    }
    if updated {
        // 返回重启标记退出码
        os.Exit(2)
    }

    // 执行核心任务
    performDownloadAndExtract()
}

优势 #

• A的代码改动极小；
• 逻辑简单可靠，兼容性强。

内容的提问来源于stack exchange，提问作者Abhinav Geethan