golang进程启动及监控方式

Golang进程启动及监控

在构建需要长期稳定运行的后台服务时，尤其是像边缘智能程序这类场景，进程的可靠性和自愈能力至关重要。今天，我们就来深入探讨两种在Go语言中实现进程守护与监控的实用方案。

• 守护进程（Daemon）：核心目标是将目标进程与终端解耦，使其能在后激进分子立、稳定地运行。
• 监控进程（Forever）：更进一步，为目标进程加上“不死之身”，在其意外退出时能自动重启，保障服务连续性。

Go语言在启动子进程方面提供了优雅的封装——os/exec包中的exec.Command。本文将围绕这个核心工具，展示两种不同设计思路的实现方式。

1.1 集成式实现：与业务代码耦合

第一种思路是将守护逻辑直接嵌入到需要被监控的业务程序内部。通过命令行参数来触发守护模式，实现“一体两面”。

来看核心代码文件 test.go：

package test

import (
 "flag"
 "fmt"
 "os"
 "os/exec"
 "time"
)
func main() {
 daemon := flag.Bool("deamon", false, "run in daemon and forever")
 flag.Parse()
 //判断是否以守护进程的方式启动
 if *daemon {
  runbydeamon(os.Args) //执行deamon，由其启动主程序
 }
 //业务主程序代码
 fmt.Println("start test Service")
}

//以deamon的方式启动程序，并监控进程
func runbydeamon(args []string) {
 fmt.Printf("PID: %d PPID: %d ARG: %s\n", os.Getpid(), os.Getppid(), os.Args)
 //去掉-deamon运行参数，启动主程序
 for i := 0; i < len(args); {
  if args[i] == "-deamon" && i != len(args)-1 {
   args = append(args[:i], args[i+1:]...)
  } else if args[i] == "-deamon" && i == len(args)-1 {
   args = args[:i]
  } else {
   i++
  }
 }
 //启动子进程,去掉-deamon参数后，执行程序，由于子程序无deamon参数，因此会直接执行业务代码
 for {
  cmd := exec.Command(args[0], args[1:]...)
  cmd.Stdin = os.Stdin
  cmd.Stdout = os.Stdout
  cmd.Stderr = os.Stderr
  err := cmd.Start()//开启子进程
  if err != nil {
   fmt.Fprintf(os.Stderr, "start oasis erir [-] Error: %s\n", err)
   return
  }
  fmt.Println("run oasis bydeamon,pid=", cmd.Process.Pid, ",ppid=", os.Getpid(), "args=", args, "time=", time.Now())
  cmd.Wait() //阻塞等待进程退出
 }
}

它的工作原理非常清晰：当使用 go build 编译后，执行 test -deamon 命令，程序会启动两个 test 进程。

第一个进程（父进程）因为携带了 -deamon 参数，会进入 runbydeamon 函数。这个函数做了两件关键事：首先，它会巧妙地过滤掉命令行中的 -deamon 参数；然后，在一个无限循环中，使用处理后的参数重新启动子进程。

由于子进程启动时已不包含 -deamon 参数，它会直接跳转到业务代码部分，打印出 start test Service。而此时，父进程（守护进程）则通过 cmd.Wait() 阻塞等待。一旦子进程异常退出，Wait() 返回，循环便会再次启动一个新的子进程，从而实现自动重启的监控效果。

1.2 分离式实现：通用守护进程

虽然集成式方案启动简单（一个参数搞定），但仔细想想，守护进程的逻辑和具体的业务逻辑其实并无必然联系。将它们硬编码在一起，不仅降低了代码的复用性，也让业务代码变得不够纯粹。

于是，更优雅的第二种思路诞生了：将守护功能抽离成一个独立的、通用的守护程序。这样一来，任何进程都可以通过它来获得后台运行和自动重启的能力。

首先是独立的守护程序 deamon.go：

package deamon

import (
 "flag"
 "fmt"
 "os"
 "os/exec"
 "time"
)
func main() {
 pcmd := flag.String("cmd", "", "run cmd in daemon and forever")
 flag.Parse()
 runbydeamon(*pcmd) //执行deamon，由其启动主程序
}

//以deamon的方式启动程序，并监控进程
func runbydeamon(args string) {
 fmt.Printf("PID: %d PPID: %d ARG: %s\n", os.Getpid(), os.Getppid(), os.Args)
 if cmd==""{
    fmt.Println("cmd is null")
    os.Exit(0)
 }
 //启动子进程,既是去掉-deamon参数后，执行程序，由于子程序无deamon参数，因此会直接执行业务代码
 for {
  cmd := exec.Command(args[1], args[2:]...)
  cmd.Stdin = os.Stdin
  cmd.Stdout = os.Stdout
  cmd.Stderr = os.Stderr
  err := cmd.Start()//开启子进程
  if err != nil {
   fmt.Fprintf(os.Stderr, "start oasis erir [-] Error: %s\n", err)
   return
  }
  fmt.Println("run oasis bydeamon,pid=", cmd.Process.Pid, ",ppid=", os.Getpid(), "args=", args, "time=", time.Now())
  cmd.Wait() //阻塞等待进程退出
 }
}

而业务程序则变得极其干净，只剩下核心逻辑 test.go：

package test
import (
 "flag"
 "fmt"
)
func main() {
   fmt.Println("start test Service") 
}

使用方式也变得非常直观：

• 启动基础命令：deamon -cmd “test”
• 传递参数给业务进程：deamon -cmd “test” -c “config.yaml”

这里的 -cmd 参数接收需要被守护的命令及其参数。守护进程会原封不动地将 -cmd 之后的参数传递给子进程。当然，关于命令行标志（flag）的定义，完全可以根据实际需求进行扩展和定制，上面的代码只是一个清晰的示例。

总结

两种方案各有千秋：集成式方案部署便捷，适合快速原型或对复用性要求不高的场景；分离式方案则体现了“单一职责”和“高复用”的设计思想，更适合构建标准化的运维体系。在实际项目中，可以根据团队规范和具体需求灵活选择。希望这两种实现思路能为大家在构建高可用Go服务时提供有价值的参考。

您可能感兴趣的文章:

• GOLang判断进程是否存在实现方式
• golang 设置进程退出时kill所有子进程的三种方法
• Golang仿ps实现获取Linux进程信息
• 源码剖析Golang如何fork一个进程
• Golang守护进程用法示例分析
• golang进程内存控制避免docker内oom
• golang进程在docker中OOM后hang住问题解析