首页 > 脚本中心 > Golang > Golang守护进程用法示例分析

Golang守护进程用法示例分析

福牛 5月 16, 2023 18 0

前言

golang实现守护进程，包含功能：

1. 守护进程只创建一次

2. 平滑创建业务进程

3. 业务进程挂起，守护进程能监听，并重启新启业务进程

4. 守护进程退出，也能保证业务进程退出

5. 业务进程≈子进程

6. 不影响业务进程逻辑

7. 以linux平台为主，其他平台暂时没有实施条件

分析

上一篇博文讨论过如何以脚本的形式创建守护进程，这篇讨论如何以纯golang脚本实现守护进程的功能

  • 在 Unix 中，创建一个进程，通过系统调用 fork 实现（及其一些变种，如 vfork、clone）。
  • 在 Go 语言中，Linux 下创建进程使用的系统调用是 clone 。

在 C 语言中，通常会用到 2 种创建进程方法：

fork

  1. pid = fork();
  2. //pid > 0 父进程
  3. //pid = 0 子进程
  4. //pid < 0 出错

程序会从 fork 处一分为二，父进程返回值大于0，并继续运行；子进程获得父进程的栈、数据段、堆和执行文本段的拷贝，返回值等于0，并向下继续运行。通过 fork 返回值可轻松判断当前处于父进程还是子进程。

execve

  1. execve(pathname, argv, envp);
  2. //pathname 可执行文件路径
  3. //argv 参数列表
  4. //envp 环境变量列表

execve 为加载一个新程序到当前进程的内存，这将丢弃现存的程序文本段，并为新程序重新创建栈、数据段以及堆。通常将这一动作称为执行一个新程序。

在 Go 语言中，创建进程方法主要有 3 种：

exec.Command

  1. //判 断当其是否是子进程，当父进程return之后，子进程会被 系统1 号进程接管
  2. if os.Getppid() != 1 {
  3.      // 将命令行参数中执行文件路径转换成可用路径
  4.      filePath, _ := filepath.Abs(os.Args[0])
  5.      cmd := exec.Command(filePath, os.Args[1:]…)
  6.      // 将其他命令传入生成出的进程
  7.      cmd.Stdin = os.Stdin // 给新进程设置文件描述符，可以重定向到文件中
  8.      cmd.Stdout = os.Stdout
  9.      cmd.Stderr = os.Stderr
  10.      cmd.Start() // 开始执行新进程，不等待新进程退出
  11.      os.Exit(0)
  12. }

os.StartProcess

  1. if os.Getppid()!=1{
  2.      args:=append([]string{filePath},os.Args[1:]…)
  3.      os.StartProcess(filePath,args,&os.ProcAttr{Files:[]*os.File{os.Stdin,os.Stdout,os.Stderr}})
  4.      os.Exit(0)
  5. }

syscall.RawSyscall(syscall.SYS_FORK, 0, 0, 0)

  1. pid, _, sysErr := syscall.RawSyscall(syscall.SYS_FORK, 0, 0, 0)
  2. if sysErr != 0 {
  3.      Utils.LogErr(sysErr)
  4.      os.Exit(0)
  5. }

方法1和方法2通过 os.Getppid()!=1进行判断是否子进程，默认父进程退出之后，子进程会被1号进程接管。

但据Ubuntu Desktop 本地测试，接管孤儿进程的并不是1号进程，因此考虑到程序稳定性和兼容性，不能够以 ppid 作为判断父子进程的依据。

方法3直接进行了系统调用，虽然可以通过 pid 进行判断父子进程，但该方法过于底层。

综上，以exec.Command方式，通过控制参数实现守护进程

实现

  1. func main() {
  2.      // ———————— 守护进程 start ————————
  3.      basePath, _ := os.Getwd()
  4.      baseDir := filepath.Dir(basePath)
  5.      fmt.Println(fmt.Sprintf(“basePath is %s and baseDir is %s”, basePath, baseDir))
  6.      // step1
  7.      // 创建监听退出chan
  8.      c := make(chan os.Signal)
  9.      // 监听指定信号 ctrl+c kill
  10.      signal.Notify(c, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
  11.      go func() {
  12.          for s := range c {
  13.              switch s {
  14.              case syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT:
  15.                  utils.StopBusinessProcess(fmt.Sprintf(“go_start | grep business”))
  16.                  os.Exit(0)
  17.          default:
  18.                  fmt.Println(“test stop others…”)
  19.              }
  20.          }
  21.      }()
  22.      fmt.Println(fmt.Sprintf(“os.args is %v”, os.Args))
  23.      join := strings.Join(os.Args, “”)
  24.      // step2
  25.      if !strings.Contains(join, “-daemon”) {
  26.          fmt.Println(“enter daemon branch…”)
  27.          isE, ierr := utils.CheckProRunning(“go_start | grep daemon”)
  28.          if ierr != nil {
  29.              fmt.Println(“check daemon process failed, “ + ierr.Error())
  30.              return
  31.          }
  32.          if isE {
  33.              fmt.Println(“daemon process exist!”)
  34.          } else {
  35.              fmt.Println(“start daemon process…”)
  36.              // 启动守护进程
  37.              cmd := exec.Command(os.Args[0], “-c”, os.Args[2], “-d”, os.Args[4], “-e”, os.Args[6], “-daemon”)
  38.              cmd.Stdin = os.Stdin
  39.              cmd.Stdout = os.Stdout
  40.              cmd.Stderr = os.Stderr
  41.              strerr := cmd.Start()
  42.              if strerr != nil {
  43.                  fmt.Println(“start daemon process fail,” + strerr.Error())
  44.                  return
  45.              }
  46.              fmt.Println(“start daemon process success!”)
  47.              time.Sleep(time.Second * 2)
  48.              daePid := cmd.Process.Pid
  49.              isDae, daeErr := utils.CheckProRunning(“go_start | grep daemon”)
  50.              if daeErr != nil {
  51.                  fmt.Println(“check daemon process failed, “ + daeErr.Error())
  52.                  return
  53.              }
  54.              if isDae {
  55.                  fmt.Println(fmt.Sprintf(“start daemon process success, pid is %d”, daePid))
  56.                  return
  57.              } else {
  58.                  fmt.Println(“warning! start business process fail…”)
  59.              }
  60.          }
  61.      }
  62.      // step3
  63.      join = strings.Join(os.Args, “”)
  64.      if strings.Contains(join, “-daemon”) {
  65.          fmt.Println(“enter business branch…”)
  66.          for {
  67.              exist, checkerr := utils.CheckProRunning(“go_start | grep business”)
  68.              if checkerr != nil {
  69.                  fmt.Println(“check business failed, “ + checkerr.Error())
  70.                  return
  71.              }
  72.              if exist {
  73.                  fmt.Println(“business process exist!”)
  74.                  time.Sleep(time.Second * 5)
  75.                  continue
  76.              }
  77.              fmt.Println(“start business process…”)
  78.              command := exec.Command(fmt.Sprintf(fmt.Sprintf(“%s/go_start”, basePath), “-business”, “-c”, os.Args[2], “-d”, os.Args[4], “-e”, os.Args[6]))
  79.              command.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
  80.              if comerr := command.Start(); comerr != nil {
  81.                  fmt.Println(“start business process failed, “ + comerr.Error())
  82.                  return
  83.              }
  84.              time.Sleep(time.Second * 5)
  85.              businessPid := command.Process.Pid
  86.              exist, checkerr = utils.CheckProRunning(“go_start | grep business”)
  87.              if checkerr != nil {
  88.                  fmt.Println(“check business process failed, “ + checkerr.Error())
  89.                  return
  90.              }
  91.              if exist {
  92.                  fmt.Println(fmt.Sprintf(“start business process suceess, pid is %d”, businessPid))
  93.              } else {
  94.                  fmt.Println(“warning! start business process fail…”)
  95.              }
  96.          }
  97.      }
  98.      // ———————— 守护进程 end ————————
  99.      // ———————— 业务进程 start ————————
  100.      fmt.Println(“hello, welcome to business detail!”)
  101. }

相关工具方法：

  1. package utils
  2. import (
  3.      “os”
  4.      “fmt”
  5.      “go_start/core/global”
  6.      “os/exec”
  7.      “runtime”
  8.      “strconv”
  9.      “strings”
  10.      “syscall”
  11. )
  12. func StopBusinessProcess(serverName string) {
  13.      global.G_LOG.Info(“start to stop business…”)
  14.      pid, _ := GetPid(serverName)
  15.      if pid > 0 {
  16.          global.G_LOG.Info(fmt.Sprintf(“stop %s …”, serverName))
  17.          syscall.Kill(pid, syscall.SIGKILL)
  18.          global.G_LOG.Info(fmt.Sprintf(“stop business success, pid is %d”, pid))
  19.      }
  20. }
  21. //根据进程名判断进程是否运行
  22. func CheckProRunning(serverName string) (bool, error) {
  23.      a := `ps -ef|grep ` + serverName + `|grep -v grep|awk ‘{print $2}’`
  24.      pid, err := runCommand(a)
  25.      if err != nil {
  26.          return false, err
  27.      }
  28.      return pid != “”, nil
  29. }
  30. //根据进程名称获取进程ID
  31. func GetPid(serverName string) (pid int, err error) {
  32.      a := `ps -ef|grep ` + serverName + `|grep -v grep|awk ‘{print $2}’`
  33.      var pidStr string
  34.      if pidStr, err = runCommand(a); err != nil {
  35.          return
  36.      }
  37.      pid, err = strconv.Atoi(pidStr)
  38.      return
  39. }
  40. func runCommand(cmd string) (string, error) {
  41.      if runtime.GOOS == “Windows“ {
  42.          return runInWindows(cmd)
  43.      } else {
  44.          return runInLinux(cmd)
  45.      }
  46. }
  47. func runInWindows(cmd string) (string, error) {
  48.      result, err := exec.Command(“cmd”, “/c”, cmd).Output()
  49.      if err != nil {
  50.          return “”, err
  51.      }
  52.      return strings.TrimSpace(string(result)), err
  53. }
  54. func runInLinux(cmd string) (string, error) {
  55.      result, err := exec.Command(“/bin/sh”, “-c”, cmd).Output()
  56.      if err != nil {
  57.          return “”, err
  58.      }
  59.      return strings.TrimSpace(string(result)), err
  60. }

说明

1、启动go_start二进制文件，方式：./go_start -c param1 -d param2 -e param3，这里第一次进入main方法

2、main方法中，os.Args = [./go_start -c param1 -d param2 -c param3]，此时不包含”-daemon”参数，进入step2，走创建守护进程代码分支，执行创建守护进程，exec.Command(./go_start -c param1 -d param2 -e param3 -daemon)，第二次进入main方法

3、main方法中，os.Args = [./go_start -c param1 -d param2 -c param3 -daemon]，此时包含”-daemon”，进入step3，走创建业务进程分支，执行创建业务进程，exec.Command(./go_start -c param1 -d param2 -e param3)；此时守护进程存在，每隔5秒监听一次业务进程是否存在，如果存在则不操作；不存在则重新执行创建业务进程exec.Command(./go_start -c param1 -d param2 -e param3)；

4、执行具体的业务进程逻辑

验证

ps -ef | grep go_start

]$ 110  1   ./go_start -c param1 -d param2 -c param3             — ①
]$ 111  1   ./go_start -c param1 -d param2 -c param3 -daemon     — ②
]$ 112  111 ./go_start -business -c param1 -d param2 -c param3   — ③

刚开始会出现三个进程，假设进程id如上，一会之后①会消失，这是正常的，因为刚开始的启动就是①，然后只剩下进程②和③

]$ 111  1   ./go_start -c param1 -d param2 -c param3 -daemon     — ②
]$ 112  111 ./go_start -business -c param1 -d param2 -c param3   — ③

验证kill业务进程：会启动新的业务进程，守护进程不变；所以执行：kill 112

]$ 111  1   ./go_start -c param1 -d param2 -c param3 -daemon     — ②
]$ 112  111 [go_start] <defunct>                                 — ③’
]$ 113  111 ./go_start -business -c param1 -d param2 -c param3   — ③

这里kill 112后，会出现一个僵尸进程，不影响实际业务进程的创建和运行，不需要理会；假设新创建的业务进程pid为113

验证kill守护进程：整个程序退出，也就是执行ps -ef | grep go_start后，没有对应的守护进程和业务进程，同时僵尸进程也会消失；得益于以下代码，进程组

command.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}

综上

纯golang语言形式实现了守护进程，针对启动业务进程，优化点：可以使用go func(){}()协程方式启动更优雅，这里先不实施，待后续有空改进；

缺点：依然要通过参数控制守护进程和业务进程，-daemon -business，期望统一起来，不用参数控制

放在(3)实现

附录

以下是关于信号量的一个记录，当作参考文档

信号 值 动作 说明
SIGHUP 1 Term 终端控制进程结束(终端连接断开)
SIGINT 2 Term 用户发送INTR字符(Ctrl+C)触发
SIGQUIT 3 Core 用户发送QUIT字符(Ctrl+/)触发
SIGILL 4 Core 非法指令(程序错误、试图执行数据段、栈溢出等)
SIGABRT 6 Core 调用abort函数触发
SIGFPE 8 Core 算术运行错误(浮点运算错误、除数为零等)
SIGKILL 9 Term 无条件结束程序(不能被捕获、阻塞或忽略)
SIGSEGV 11 Core 无效内存引用(试图访问不属于自己的内存空间、对只读内存空间进行写操作)
SIGPIPE 13 Term 消息管道损坏(FIFO/Socket通信时，管道未打开而进行写操作)
SIGALRM 14 Term 时钟定时信号
SIGTERM 15 Term 结束程序(可以被捕获、阻塞或忽略)
SIGUSR1 30,10,16 Term 用户保留
SIGUSR2 31,12,17 Term 用户保留
SIGCHLD 20,17,18 Ign 子进程结束(由父进程接收)
SIGCONT 19,18,25 Cont 继续执行已经停止的进程(不能被阻塞)
SIGSTOP 17,19,23 Stop 停止进程(不能被捕获、阻塞或忽略) SIGTSTP 18,20,24 Stop 停止进程(可以被捕获、阻塞或忽略) SIGTTIN 21,21,26 Stop 后台程序从终端中读取数据时触发 SIGTTOU 22,22,27 Stop 后台程序向终端中写数据时触发

到此这篇关于Golang守护进程用法示例分析的文章就介绍到这了,更多相关Golang守护进程内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

标签

相关推荐

发表评论