前言

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

1. 守护进程只创建一次

2. 平滑创建业务进程

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

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

5. 业务进程≈子进程

6. 不影响业务进程逻辑

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

分析

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

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

• 在 Go 语言中，Linux 下创建进程使用的系统调用是 clone 。

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

1. fork

pid = fork();
//pid > 0 父进程
//pid = 0 子进程
//pid < 0 出错

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

2. execve

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

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

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

1. exec.Command

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

2. os.StartProcess

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

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

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

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

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

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

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

实现

func main() {// ------------------------ 守护进程 start ------------------------basePath, _ := os.Getwd()baseDir := filepath.Dir(basePath)fmt.Println(fmt.Sprintf("basePath is %s and baseDir is %s", basePath, baseDir))// step1// 创建监听退出chanc := make(chan os.Signal)// 监听指定信号 ctrl+c killsignal.Notify(c, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)go func() {for s := range c {switch s {case syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT:utils.StopBusinessProcess(fmt.Sprintf("go_start | grep business"))os.Exit(0)default:fmt.Println("test stop others...")}}}()fmt.Println(fmt.Sprintf("os.args is %v", os.Args))join := strings.Join(os.Args, "")// step2if !strings.Contains(join, "-daemon") {fmt.Println("enter daemon branch...")isE, ierr := utils.CheckProRunning("go_start | grep daemon")if ierr != nil {fmt.Println("check daemon process failed, " + ierr.Error())return}if isE {fmt.Println("daemon process exist!")} else {fmt.Println("start daemon process...")// 启动守护进程cmd := exec.Command(os.Args[0], "-c", os.Args[2], "-d", os.Args[4], "-e", os.Args[6], "-daemon")cmd.Stdin = os.Stdincmd.Stdout = os.Stdoutcmd.Stderr = os.Stderrstrerr := cmd.Start()if strerr != nil {fmt.Println("start daemon process fail," + strerr.Error())return}fmt.Println("start daemon process success!")time.Sleep(time.Second * 2)daePid := cmd.Process.PidisDae, daeErr := utils.CheckProRunning("go_start | grep daemon")if daeErr != nil {fmt.Println("check daemon process failed, " + daeErr.Error())return}if isDae {fmt.Println(fmt.Sprintf("start daemon process success, pid is %d", daePid))return} else {fmt.Println("warning! start business process fail...")}}}// step3join = strings.Join(os.Args, "")if strings.Contains(join, "-daemon") {fmt.Println("enter business branch...")for {exist, checkerr := utils.CheckProRunning("go_start | grep business")if checkerr != nil {fmt.Println("check business failed, " + checkerr.Error())return}if exist {fmt.Println("business process exist!")time.Sleep(time.Second * 5)continue}fmt.Println("start business process...")command := exec.Command(fmt.Sprintf(fmt.Sprintf("%s/go_start", basePath), "-business", "-c", os.Args[2], "-d", os.Args[4], "-e", os.Args[6]))command.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}if comerr := command.Start(); comerr != nil {fmt.Println("start business process failed, " + comerr.Error())return}time.Sleep(time.Second * 5)businessPid := command.Process.Pidexist, checkerr = utils.CheckProRunning("go_start | grep business")if checkerr != nil {fmt.Println("check business process failed, " + checkerr.Error())return}if exist {fmt.Println(fmt.Sprintf("start business process suceess, pid is %d", businessPid))} else {fmt.Println("warning! start business process fail...")}}}// ------------------------ 守护进程 end ------------------------// ------------------------ 业务进程 start ------------------------fmt.Println("hello, welcome to business detail!")}

相关工具方法：

package utilsimport ("os""fmt""go_start/core/global""os/exec""runtime""strconv""strings""syscall"
)func StopBusinessProcess(serverName string) {global.G_LOG.Info("start to stop business...")pid, _ := GetPid(serverName)if pid > 0 {global.G_LOG.Info(fmt.Sprintf("stop %s ...", serverName))syscall.Kill(pid, syscall.SIGKILL)global.G_LOG.Info(fmt.Sprintf("stop business success, pid is %d", pid))}
}//根据进程名判断进程是否运行
func CheckProRunning(serverName string) (bool, error) {a := `ps -ef|grep ` + serverName + `|grep -v grep|awk '{print $2}'`pid, err := runCommand(a)if err != nil {return false, err}return pid != "", nil
}//根据进程名称获取进程ID
func GetPid(serverName string) (pid int, err error) {a := `ps -ef|grep ` + serverName + `|grep -v grep|awk '{print $2}'`var pidStr stringif pidStr, err = runCommand(a); err != nil {return}pid, err = strconv.Atoi(pidStr)return
}func runCommand(cmd string) (string, error) {if runtime.GOOS == "windows" {return runInWindows(cmd)} else {return runInLinux(cmd)}
}func runInWindows(cmd string) (string, error) {result, err := exec.Command("cmd", "/c", cmd).Output()if err != nil {return "", err}return strings.TrimSpace(string(result)), err
}func runInLinux(cmd string) (string, error) {result, err := exec.Command("/bin/sh", "-c", cmd).Output()if err != nil {return "", err}return strings.TrimSpace(string(result)), err
}

说明

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   -- ③

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

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

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

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

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

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

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

综上

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

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

放在(3)实现

附录

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