golang 后台进程 daemon方式运行简介

申博厚

2023-12-01

1.前言

1.前言

因为最近用go语言开发了一个websocket服务，启动后需要后台运行，还希望异常退出时可以自动重启。整体思路是启动程序后，转为后台运行，这个后台程序暂且称为守护进程（daemon）。它不处理具体业务逻辑，只是再次按一样的参数调用自身，启动一个子进程，有子进程负责业务逻辑处理。守护进程监视子进程状态，若退出则再次启动一次。如此可以保证服务异常中止时可以及时重启。

网上找到了一个开源的库github.com/sevlyar/go-daemon，可以很方便保持参数不变另外启动一个后台进程，但如果后台进程再次尝试启动自身为另外一个后台进程，则会出现错误。后来阅读源码发现：为了区分当前进程是父进程还是子进程，作者巧妙的设计了一个环境变量标识，用于标记子进程。也正是因为这种识别策略，此库只能启动一次自身为后台进程，不能连续启动自身为后台进程。不过使用环境变量来区分进程身份的思路，对我启发很大。在此基础上经过延伸和优化，最终实现了在保持参数不变的情况可以连续启动自身为后台进程。向作者致敬！

另外还找了一些库，思路有所不同，基本是通过增加特殊参数来标记进程身份的，这让我感并没有完美的启动了自身进程，有些遗憾。

最终决定自己实现一个库解决我项目中的需求，同时也期望它是一个很通用的库，可以快速方便把go语言编写的服务程序转为后台运行，或者转为守护进程的模式运行。本文算是对这次探索的一次总结和梳理。

2.区分两个概念

后台运行和daemon在平常沟通中我们可能不太区分，或者区分得比较模糊。在本文所指中，我要明确区分一下：

后台运行：是指进程在操作系统中非显示运行，未关联到任何命令行终端或程序界面。这中方式运行的进程则称为后台进程，如未关联到任何终端的命令行程序进程。

daemon：也叫守护进程，它首先是后台运行，然后它还有守护的职责。本文所指，是希望守护进程可以监视go服务程序进程的状态，若异常退出，可以自动重启服务程序。

3.首先排除的方案

nohub、&、setsid都可以让程序在后台运行，但这是平台相关的，只适用于类unix系统。若使用此类方案，那这个库在windows下是无法工作的，不太完美。先不说支持所有平台，我期望这个库至少能支持类unix系统和windows系统。

4.相关的标准库的探索

因为种种原因，在go语言中我们无法很好的直接操作 fork 调用。我们转换一下思路，启动自身为一个子进程，也可以看做是调用外部程序。标准库中找到下面三种方法: - syscall.ForkExec - os.StartProcess - exec.Cmd

syscall.ForkExec的文档说明不是很多，我没有深入研究。阅读那些开源库，发现基本都是使用os.StartProcess或exec.Cmd。 os.StartProcess在文档里有明确说明，这是一个低水平的接口，建议使用os/exec包提供的高水平接口，也就是exec.Cmd。

func StartProcess(name string, argv []string, attr *ProcAttr) (*Process, error) StartProcess使用提供的属性、程序名、命令行参数开始一个新进程。StartProcess函数是一个低水平的接口。os/exec包提供了高水平的接口，应该尽量使用该包。如果出错，错误的底层类型会是*PathError。

查标准库文档，exec.Cmd结构体的说明如下，功能非常的强大，有很多属性可以定制。

type Cmd struct {
    // Path是将要执行的命令的路径。
    //
    // 该字段不能为空，如为相对路径会相对于Dir字段。
    Path string
    // Args保管命令的参数，包括命令名作为第一个参数；如果为空切片或者nil，相当于无参数命令。
    //
    // 典型用法下，Path和Args都应被Command函数设定。
    Args []string
    // Env指定进程的环境，如为nil，则是在当前进程的环境下执行。
    Env []string
    // Dir指定命令的工作目录。如为空字符串，会在调用者的进程当前目录下执行。
    Dir string
    // Stdin指定进程的标准输入，如为nil，进程会从空设备读取（os.DevNull）
    Stdin io.Reader
    // Stdout和Stderr指定进程的标准输出和标准错误输出。
    //
    // 如果任一个为nil，Run方法会将对应的文件描述符关联到空设备（os.DevNull）
    //
    // 如果两个字段相同，同一时间最多有一个线程可以写入。
    Stdout io.Writer
    Stderr io.Writer
    // ExtraFiles指定额外被新进程继承的已打开文件流，不包括标准输入、标准输出、标准错误输出。
    // 如果本字段非nil，entry i会变成文件描述符3+i。
    //
    // BUG: 在OS X 10.6系统中，子进程可能会继承不期望的文件描述符。
    // http://golang.org/issue/2603
    ExtraFiles []*os.File
    // SysProcAttr保管可选的、各操作系统特定的sys执行属性。
    // Run方法会将它作为os.ProcAttr的Sys字段传递给os.StartProcess函数。
    SysProcAttr *syscall.SysProcAttr
    // Process是底层的，只执行一次的进程。
    Process *os.Process
    // ProcessState包含一个已经存在的进程的信息，只有在调用Wait或Run后才可用。
    ProcessState *os.ProcessState
    // 内含隐藏或非导出字段
}

与exec.Cmd相关的方法也有不少，后面我们将使用这些属性和方法完成让go程序后台运行的目标。

type Cmd
func Command(name string, arg ...string) *Cmd
func (c *Cmd) StdinPipe() (io.WriteCloser, error)
func (c *Cmd) StdoutPipe() (io.ReadCloser, error)
func (c *Cmd) StderrPipe() (io.ReadCloser, error)
func (c *Cmd) Run() error
func (c *Cmd) Start() error
func (c *Cmd) Wait() error
func (c *Cmd) Output() ([]byte, error)
func (c *Cmd) CombinedOutput() ([]byte, error)

5.尝试让go程序后台运行

5.1 go调用普通外部程序

我们比较常用的是exec.Command()方法，如以下例子是阻塞调用外部shell命令，并获得命令的执行结果输出

//示例：shell.go

package main

import (
    "fmt"
    "os/exec"
    "bytes"
)

func main() {
    str, err := execShell("ls -l /|head -n 3")
    fmt.Println(err)
    fmt.Println(str)
}

//@link https://www.zhihu.com/people/zh-five
func execShell(s string) (string, error) {
    //这里是一个小技巧, 以'/bin/bash -c xxx'的方式调用shell命令, 则可以在命令中使用管道符,组合多个命令
    cmd := exec.Command("/bin/bash", "-c", s)
    var out bytes.Buffer
    cmd.Stdout = &out //把执行命令的标准输出定向到out
    cmd.Stderr = &out //把命令的错误输出定向到out

    //启动一个子进程执行命令,阻塞到子进程结束退出
    err := cmd.Run()
    if err != nil {
        return "", err
    }

    return out.String(), err
}

执行go run shell.go运行程序后，我的MAC系统输出了：

$ go run shell.go
<nil>
total 21
drwxrwxr-x+ 109 root  admin  3488  6  4 16:17 Applications
drwxr-xr-x+  69 root  wheel  2208 12 22 23:19 Library

以上例子执行的是shell命令ls -l /|head -n 3，其实这个命令可以是任何可以在命令终端执行的程序。那么若这个程序是go程序自身，那就相当于是fork了一个子进程。后续我们将尝试完成这个工作。

5.2 go程序调用自身转为后台运行

我们调用自身程序成功后，是希望子进程可以独自运行，然后父进程退出。这与上面调用外部程序的例子有几点不一样了：

调用自身程序时，父进程不能以阻塞的方式进行了。因为若阻塞了，那就无法提前退出了
父进程不能等待获取子进程的结果输出了，同样是为了提前退出

非阻塞问题：查标准库，exec.Cmd是可以使用func (c *Cmd) Start() error非阻塞式运行外部程序的。若启动外部程序成功则返回nil，否则返回错误信息。

子进程的结果输出问题：查看本文之前引用的标准库文档exec.Cmd的两个属性Stdout和Stderr（标准输出和错误输出）都是io.Writer接口。那么我们就可以把标准输出和错误输出定向到日志文件中。当然若不需要，也可以不用设置Stdout和Stderr两个属性，系统将抛弃子进程标准输出和错误输出的信息。

按以上的解决方案，我代码修改一下，用于启动go程序自身

// !!! 切勿运行此程序 !!!
//示例：self.go

package main

import (
    "log"
    "os"
    "os/exec"
)

func main() {
    background("/tmp/daemon.log")
}

func background(logFile string) error {
    //os.Args 是一个切片,保管了命令行参数，第一个是程序名
    //go程序启动时不包含管道符了,就直接运行了
    cmd := exec.Command(os.Args[0], os.Args[1:]...)

    //若有日志文件, 则把子进程的输出导入到日志文件
    if logFile != "" {
        stdout, err := os.OpenFile(logFile, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)
        if err != nil {
            log.Println(os.Getpid(), ": 打开日志文件错误:", err)
            return err
        }
        cmd.Stderr = stdout
        cmd.Stdout = stdout
    }

    //异步启动子进程
    err := cmd.Start()
    if err != nil {
        return err
    }

    return nil
}

以上代码粗看起来好像没有问题，但仔细一想，会存在一个问题：启动的子进程也会执行background()方法，再次启动一个子进程。如此循环，会不断的创建子进程。也就是说以上例子里，代码无法判断自身是父进程还是子进程。

解决怎么区分父进程子进程的问题

为了区分子进程父进程，大多数开源库的解决方案是设置特殊的参数。这种方案是入侵式的，新设置的参数，有可能和go程序原有参数冲突。虽然设置一些奇怪的参数名来降低冲突概率，但至少在使用过程中，并非完全保持参数原样启动子进程，可能会造成使用者的迷惑。这种方案不太完美，先舍弃。

前文提过github.com/sevlyar/go-daemon是巧妙的使用了环境变量，用来区分子进程和父进程。这种方案对go程序影响更小，产生冲突的可能性更小，也避免了使用者对参数变化的迷惑。其原理是利用的是exec.Cmd的Env属性设置子进程的环境变量时，添加一个特殊的环境变量，用以标记子程序。用这个思路，我们把上面的例子修正一下。模仿C语言里的fork，返回一个可用用于判断是子进程还是父进程的数据。

//示例:self1.go

package main

import (
    "fmt"
    "log"
    "os"
    "os/exec"
    "time"
)

func main() {
    cmd, err := background("/tmp/daemon.log")
    if err != nil {
        log.Fatal("启动子进程失败:", err)
    }

    //根据返回值区分父进程子进程
    if cmd != nil { //父进程
        log.Println("我是父进程:", os.Getpid(), "; 启动了子进程:", cmd.Process.Pid, "; 运行参数", os.Args)
        return //父进程退出
    } else { //子进程
        log.Println("我是子进程:", os.Getpid(), "; 运行参数:",os.Args)
    }

    //以下代码只有子进程会执行
    log.Println("只有子进程会运行:", os.Getpid(), "; 开始...")
    time.Sleep(time.Second * 20) //休眠20秒
    log.Println("只有子进程会运行:", os.Getpid(), "; 结束")
}

//@link https://www.zhihu.com/people/zh-five
func background(logFile string) (*exec.Cmd, error) {
    envName := "XW_DAEMON" //环境变量名称
    envValue := "SUB_PROC" //环境变量值

    val := os.Getenv(envName) //读取环境变量的值,若未设置则为空字符串
    if val == envValue {      //监测到特殊标识, 判断为子进程,不再执行后续代码
        return nil, nil
    }

    /*以下是父进程执行的代码*/

    //因为要设置更多的属性, 这里不使用`exec.Command`方法, 直接初始化`exec.Cmd`结构体
    cmd := &exec.Cmd{
        Path: os.Args[0],
        Args: os.Args, //注意,此处是包含程序名的
        Env:  os.Environ(), //父进程中的所有环境变量
    }

    //为子进程设置特殊的环境变量标识
    cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", envName, envValue))

    //若有日志文件, 则把子进程的输出导入到日志文件
    if logFile != "" {
        stdout, err := os.OpenFile(logFile, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)
        if err != nil {
            log.Println(os.Getpid(), ": 打开日志文件错误:", err)
            return nil, err
        }
        cmd.Stderr = stdout
        cmd.Stdout = stdout
    }

    //异步启动子进程
    err := cmd.Start()
    if err != nil {
        return nil, err
    }

    return cmd, nil
}

注意此例子不建议使用go run直接运行，因为go run会先编译可执行文件到一个临时目录，然后再运行，其执行输出可能会有些让人迷惑。建议先编译为可执行文件后执行

#编译
$ go build self1.go

#随便设置一些参数，查看执行效果
$ ./self1 -a -b
2020/06/05 19:05:44 我是父进程: 37886 ; 启动了子进程: 37887 ; 运行参数 [./self1 -a -b]

#查看子进程 37887
$ ps -ef |grep self1
  501 37887     1   0  7:05下午 ttys003    0:00.01 ./self1 -a -b

#查看子进程输出日志
$ tail /tmp/daemon.log
2020/06/05 19:05:44 我是子进程: 37887 ; 运行参数: [./self1 -a -b]
2020/06/05 19:05:44 只有子进程会运行: 37887 ; 开始...
2020/06/05 19:06:04 只有子进程会运行: 37887 ; 结束

从日志输出看，我们成功的把go程序已自身转为了一个后台运行的子进程，并且子进程的运行参数和父进程完全一样。

如此，我们的目标可以说是完成了一半。接下来是尝试完成守护进程的功能，肯定会涉及到的一个问题是：在子进程中再次启动子进程。那我们思考一下：现在的background方法可以完成此工作吗？答案是不能，我们还需继续优化。

5.3 如何在子进程中再次启动子进程

我们若在子进程中调用background方法，会发现是无法启动新的子进程的。原因是不管第几次调用background方法，环境变量的判断结果都是一样。有两个因素并没有考虑到：

第几次调用background
当前子进程是第几代子进程

结合这两个因素，我们似乎可以设计出一个判断策略，background知道什么时候我该启动子进程，什么时候不该启动。我们设计一个变量ruuIdx记录调用background的次数，启动子进程时把此计数写入到子进程的环境变量中，用于标记此进程是第几代子进程（envIdx）。显然，在子进程中，若runIdx等于envIdx时，那父进程正是调用了此次的background而启动了这个子进程。推导判断一下其它情况，可制定完成的策略如下：

runIdx = envIdx时：代表意义如上所述，不启动子进程
runIdx < envIdx时：表示是启动前几代子进程的调用，不启动子进程
runIdx > envIdx时：表示需要启动新启动一个子进程

按此思路继续改进background

//示例:self2.go

package main

import (
    "fmt"
    "log"
    "os"
    "os/exec"
    "strconv"
    "time"
)

func main() {
    logFile := "/tmp/daemon.log"
    background(logFile, true) //启动子进程后退出
    background(logFile, true) //启动子进程后退出
    background(logFile, true) //启动子进程后退出

    //以下代码只有最后一代子进程会执行
    log.Println(os.Getpid(), "业务代码开始...")
    time.Sleep(time.Second * 20) //休眠20秒
    log.Println(os.Getpid(), "业务代码结束")
}

var runIdx int = 0               //background调用计数
const ENV_NAME = "XW_DAEMON_IDX" //环境变量名

//@link https://www.zhihu.com/people/zh-five
func background(logFile string, isExit bool) (*exec.Cmd, error) {
    //判断子进程还是父进程
    runIdx++
    envIdx, err := strconv.Atoi(os.Getenv(ENV_NAME))
    if err != nil {
        envIdx = 0
    }
    if runIdx <= envIdx { //子进程, 退出
        return nil, nil
    }

    /*以下是父进程执行的代码*/

    //因为要设置更多的属性, 这里不使用`exec.Command`方法, 直接初始化`exec.Cmd`结构体
    cmd := &exec.Cmd{
        Path: os.Args[0],
        Args: os.Args,      //注意,此处是包含程序名的
        Env:  os.Environ(), //父进程中的所有环境变量
    }

    //为子进程设置特殊的环境变量标识
    cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", ENV_NAME, runIdx))

    //若有日志文件, 则把子进程的输出导入到日志文件
    if logFile != "" {
        stdout, err := os.OpenFile(logFile, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)
        if err != nil {
            log.Println(os.Getpid(), ": 打开日志文件错误:", err)
            return nil, err
        }
        cmd.Stderr = stdout
        cmd.Stdout = stdout
    }

    //异步启动子进程
    err = cmd.Start()
    if err != nil {
        log.Println(os.Getpid(), "启动子进程失败:", err)
        return nil, err
    } else {
        //执行成功
        log.Println(os.Getpid(), ":", "启动子进程成功:", "->", cmd.Process.Pid, "\n ")
    }

    //若启动子进程成功, 父进程是否直接退出
    if isExit {
        os.Exit(0)
    }

    return cmd, nil
}

编译后执行

#编译
$ go build self2.go

#随便设置一些参数执行
$ ./self2 -a -b -c 123
2020/06/05 19:58:27 38984 : 启动子进程成功: -> 38985

#查看进程，看到的是最终子进程
$ ps -ef |grep self2
  501 38990     1   0  7:58下午 ttys003    0:00.01 ./self2 -a -b -c 123

#查看日志
$ tail /tmp/daemon.log
2020/06/05 19:58:27 38985 : 启动子进程成功: -> 38988

2020/06/05 19:58:27 38988 : 启动子进程成功: -> 38990

2020/06/05 19:58:28 38990 业务代码开始...
2020/06/05 19:58:48 38990 业务代码结束

由日志可以看出，成功的启动了3代子进程：38984（父进程）-> 38985 -> 38988 -> 38990。最终的38990子进程执行了业务代码。

注意：此种策略判断的前提条件是，逐代启动子进程。若某进程里重复启动了多个子进程，那么其子进程若想再启动子进程，可能会失败。如以下例子

//非逐代启动子进程的异常情况
func main() {
    logFile := "/tmp/daemon.log"
    cmd,err := background(logFile, false)//启动子进程后不自动退出
    if err != nil {
        log.Fatal("启动子进程失败:", err)
    }

    //根据返回值区分父进程子进程
    if cmd != nil { //父进程
        //父进程再次启动一个子进程, 非逐代启动了
        background(logFile, true) //启动子进程后退出
        return //父进程退出
    }

    //父进程里第2次启动的子进程, 此处调用出现异常情况: 将不会启动子进程,而会直接略过执行后面的代码
    background(logFile, true) //启动子进程后退出

    //以下代码只有最后一代子进程会执行
    log.Println(os.Getpid(), "业务代码开始...")
    time.Sleep(time.Second * 20) //休眠20秒
    log.Println(os.Getpid(), "业务代码结束")
}

执行结果为

#编译
$ go build self2.go

#执行。启动了两个子进程，注意第2此启动39291进程将有异常
$ ./self2 -a -b -c 123
2020/06/05 20:16:58 39289 : 启动子进程成功: -> 39290

2020/06/05 20:16:58 39289 : 启动子进程成功: -> 39291

#查看进程
$ ps -ef |grep self2
  501 39291     1   0  8:16下午 ttys003    0:00.01 ./self2 -a -b -c 123
  501 39292     1   0  8:16下午 ttys003    0:00.01 ./self2 -a -b -c 123

#查看日志。主要只有39290再次启动了子进程，而39291则直接执行了业务代码
$ tail /tmp/daemon.log
2020/06/05 20:16:58 39290 : 启动子进程成功: -> 39292

2020/06/05 20:16:58 39291 业务代码开始...
2020/06/05 20:16:58 39292 业务代码开始...
2020/06/05 20:17:18 39291 业务代码结束
2020/06/05 20:17:18 39292 业务代码结束

若是重复启动的子进程不再启动子进程，则无影响。后续守护进程的实现，会有这种情况。

6.守护进程的实现

查标准库中有一个func (c *Cmd) Wait() error方法，可以阻塞等待子进程执行结束。守护进程的逻辑就是启动一个子进程（处理业务逻辑，可称为业务进程），然后Wait()住。若子进程退出了，则Wait()解除阻塞，再次重复一次之前的步骤。如此循环，则相当于守护了一个业务进程常驻内存，保证服务的持续性。

以下是示例代码

//守护进程的实现, 基于之前的 background() 。可以替换示例self2.go中的main()函数进行测试
func main(){
    logFile := "/tmp/daemon.log"

    //启动一个子进程作为守护进程
    background(logFile, true) //启动子进程后退出

    //在守护进程中循环启动子进程
    for{
        cmd,err := background(logFile, false)//启动子进程后不自动退出
        if err != nil {
            log.Fatal("启动子进程失败:", err)
        }

        //根据返回值区分父进程子进程
        if cmd != nil { //父进程
            cmd.Wait() //等等子进程执行结束(监视子进程)
        } else { //子进程, 跳出让其执行后续业务代码
            break
        }
    }

    //以下是业务代码
    log.Println(os.Getpid(), "业务代码开始...")
    time.Sleep(time.Second * 20) //休眠20秒
    log.Println(os.Getpid(), "业务代码结束")

}

执行结果为：

#编译
$ go build self2.go

#执行，启动的守护进程为 39541
$ ./self2 -a -b -c 123
2020/06/05 20:36:05 39540 : 启动子进程成功: -> 39541

#查看进程。可以看出，业务进程是39543，其父进程是39541
$ ps -ef |grep self2
  501 39541     1   0  8:36下午 ttys003    0:00.01 ./self2 -a -b -c 123
  501 39543 39541   0  8:36下午 ttys003    0:00.01 ./self2 -a -b -c 123

#查看日志。可以看到业务进程39543退出后，守护进程及时的启动了另一个业务进程39574
$ tail /tmp/daemon.log
2020/06/05 20:36:05 39541 : 启动子进程成功: -> 39543

2020/06/05 20:36:05 39543 业务代码开始...
2020/06/05 20:36:25 39543 业务代码结束
2020/06/05 20:36:25 39541 : 启动子进程成功: -> 39574

2020/06/05 20:36:25 39574 业务代码开始...

到此，守护进程的功能已经实现了。但作为一个库，对使用者还不太友好，我们需要封装一下。并且结合业务场景似乎还有一些细节问题需要考虑一下：

一个正常服务进程一般不会异常退出，可能并不需要无限的循环重启，这可以让使用者自定义最大重启次数
若业务进程连续不断的异常退出，是不应该继续不断重启了。可设置一个允许的最大连续异常退出次数
实际编写的服务程序，异常退出时不一定退出码就是非0。可以设置一个最短运行时间，协助判断是否是异常退出

最后封装为xdaemon库，开源在https://github.com/zh-five/xdaemon

其核心代码如下

package xdaemon

import (
    "fmt"
    "log"
    "os"
    "os/exec"
    "strconv"
    "time"
)

const ENV_NAME = "XW_DAEMON_IDX"

//运行时调用background的次数
var runIdx int = 0

//守护进程
type Daemon struct {
    LogFile     string //日志文件, 记录守护进程和子进程的标准输出和错误输出. 若为空则不记录
    MaxCount    int    //循环重启最大次数, 若为0则无限重启
    MaxError    int    //连续启动失败或异常退出的最大次数, 超过此数, 守护进程退出, 不再重启子进程
    MinExitTime int64  //子进程正常退出的最小时间(秒). 小于此时间则认为是异常退出
}

// 把本身程序转化为后台运行(启动一个子进程, 然后自己退出)
// logFile 若不为空,子程序的标准输出和错误输出将记入此文件
// isExit  启动子加进程后是否直接退出主程序, 若为false, 主程序返回*os.Process, 子程序返回 nil. 需自行判断处理
func Background(logFile string, isExit bool) (*exec.Cmd, error) {
    //判断子进程还是父进程
    runIdx++
    envIdx, err := strconv.Atoi(os.Getenv(ENV_NAME))
    if err != nil {
        envIdx = 0
    }
    if runIdx <= envIdx { //子进程, 退出
        return nil, nil
    }

    //设置子进程环境变量
    env := os.Environ()
    env = append(env, fmt.Sprintf("%s=%d", ENV_NAME, runIdx))

    //启动子进程
    cmd, err := startProc(os.Args, env, logFile)
    if err != nil {
        log.Println(os.Getpid(), "启动子进程失败:", err)
        return nil, err
    } else {
        //执行成功
        log.Println(os.Getpid(), ":", "启动子进程成功:", "->", cmd.Process.Pid, "\n ")
    }

    if isExit {
        os.Exit(0)
    }

    return cmd, nil
}

func NewDaemon(logFile string) *Daemon {
    return &Daemon{
        LogFile:     logFile,
        MaxCount:    0,
        MaxError:    3,
        MinExitTime: 10,
    }
}

// 启动后台守护进程
func (d *Daemon) Run() {
    //启动一个守护进程后退出
    Background(d.LogFile, true)

    //守护进程启动一个子进程, 并循环监视
    var t int64
    count := 1
    errNum := 0
    for {
        //daemon 信息描述
        dInfo := fmt.Sprintf("守护进程(pid:%d; count:%d/%d; errNum:%d/%d):",
            os.Getpid(), count, d.MaxCount, errNum, d.MaxError)
        if errNum > d.MaxError {
            log.Println(dInfo, "启动子进程失败次数太多,退出")
            os.Exit(1)
        }
        if d.MaxCount > 0 && count > d.MaxCount {
            log.Println(dInfo, "重启次数太多退出")
            os.Exit(0)
        }
        count++

        t = time.Now().Unix() //启动时间戳
        cmd, err := Background(d.LogFile, false)
        if err != nil { //启动失败
            log.Println(dInfo, "子进程启动失败;", "err:", err)
            errNum++
            continue
        }

        //子进程,
        if cmd == nil {
            log.Printf("子进程pid=%d: 开始运行...", os.Getpid())
            break
        }

        //父进程: 等待子进程退出
        err = cmd.Wait()
        dat := time.Now().Unix() - t //子进程运行秒数
        if dat < d.MinExitTime {     //异常退出
            errNum++
        } else { //正常退出
            errNum = 0
        }
        log.Printf("%s 监视到子进程(%d)退出, 共运行了%d秒: %v\n", dInfo, cmd.ProcessState.Pid(), dat, err)
    }
}

func startProc(args, env []string, logFile string) (*exec.Cmd, error) {
    cmd := &exec.Cmd{
        Path:        args[0],
        Args:        args,
        Env:         env,
        SysProcAttr: NewSysProcAttr(),
    }

    if logFile != "" {
        stdout, err := os.OpenFile(logFile, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)
        if err != nil {
            log.Println(os.Getpid(), ": 打开日志文件错误:", err)
            return nil, err
        }
        cmd.Stderr = stdout
        cmd.Stdout = stdout
    }

    err := cmd.Start()
    if err != nil {
        return nil, err
    }

    return cmd, nil
}

xdaemon库的使用示例

background模式

//本示例, 将把进程转为后台运行, 并保留所有参数不变

package main

import (
    "github.com/zh-five/xdaemon"
    "log"
    "os"
    "time"
)

func main() {
    logFile := "daemon.log"

    //启动一个子进程后主程序退出
    xdaemon.Background(logFile, true)

    //以下代码只有子程序会执行
    log.Println(os.Getpid(), "start...")
    time.Sleep(time.Second * 10)
    log.Println(os.Getpid(), "end")
}

daemon模式

//本示例, 将启动一个后台运行的守护进程. 然后由守护进程启动和维护最终子进程

package main

import (
    "github.com/zh-five/xdaemon"
    "flag"
    "log"
    "os"
    "time"
)

func main() {
    d := flag.Bool("d", false, "是否后台守护进程方式运行")
    flag.Parse()

    //启动守护进程
    if *d {
        //创建一个Daemon对象
        logFile := "daemon.log"
        d := xdaemon.NewDaemon(logFile)
        //调整一些运行参数(可选)
        d.MaxCount = 2 //最大重启次数

        //执行守护进程模式
        d.Run()
    }

    //当 *d = true 时以下代码只有最终子进程会执行, 主进程和守护进程都不会执行
    log.Println(os.Getpid(), "start...")
    time.Sleep(time.Second * 10)
    log.Println(os.Getpid(), "end")

}

golang 后台进程 daemon方式运行简介

1.前言

2.区分两个概念

3.首先排除的方案

4.相关的标准库的探索

5.尝试让go程序后台运行

5.1 go调用普通外部程序

5.2 go程序调用自身转为后台运行

解决怎么区分父进程子进程的问题

5.3 如何在子进程中再次启动子进程

6.守护进程的实现

xdaemon库的使用示例

相关阅读

相关文章

相关问答

相关文档

golang 后台进程 daemon方式运行 简介

1.前言

2.区分两个概念

3.首先排除的方案

4.相关的标准库的探索

5.尝试让go程序后台运行

5.1 go调用普通外部程序

5.2 go程序调用自身转为后台运行

解决怎么区分父进程子进程的问题

5.3 如何在子进程中再次启动子进程

6.守护进程的实现

xdaemon库的使用示例

相关阅读

相关文章

相关问答

相关文档

golang 后台进程 daemon方式运行简介