golang实现守护进程(2)

已于 2023-03-21 17:56:47 修改
阅读量1k 收藏 5
点赞数 1
分类专栏： 大数据 文章标签： go golang Powered by 金山文档
于 2023-03-21 17:39:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dkjhl/article/details/129691625
版权

前言

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 返回值可轻松判断当前处于父进程还是子进程。

  1. 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.Stdout
    cmd.Stderr = os.Stderr
    cmd.Start() // 开始执行新进程，不等待新进程退出
    os.Exit(0)
}

  1. 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)
}

  1. 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
    // 创建监听退出chan
    c := make(chan os.Signal)
    // 监听指定信号 ctrl+c kill
    signal.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, "")

    // step2
    if !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.Stdin
            cmd.Stdout = os.Stdout
            cmd.Stderr = os.Stderr
            strerr := 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.Pid
            isDae, 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...")
            }
        }
    }

    // step3
    join = 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.Pid
            exist, 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 utils

import (
    "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 string
    if 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   -- ③

  1. 验证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   -- ③

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

  1. 验证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 后台程序向终端中写数据时触发

dkjhl
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Linux信号量动作和说明列表
Golang客栈
05-26 557
ctrl退出指令 Ctrl-C 发送 INT signal (SIGINT)，通常导致进程结束 Ctrl-Z 发送 TSTP signal (SIGTSTP)，通常导致进程挂起(suspend) Ctrl-\ 发送 QUIT signal (SIGQUIT)，通常导致进程结束 和 dump core 举例：kill -9指令 kill -9 pid 会发送 SIGKILL信号给进程。 信号...
gund_2021_golang_rar.rar
09-22
/* 说明：本程序主要是实现Win32后台服务进程24小时监控, 当服务进程宕机后自动重启，并记录日志。 */
golang调用外部程序，创建进程，fork，守护进程，shell命令，fd查看，lsof
热门推荐
猛犸象
10-11 1万+
一、syscall.Exec() 函数原型 func Exec(argv0 string, argv []string, envv []string) (err error) 函数说明 Exec invokes the execve(2) system call. 此方法会将在当前进程空间里，用新的程序覆盖掉当前程序，并执行新的程序，它们依然在同一个进程里，只是进程的内容发生了变化。 main11.go package main import ( "fmt" "syscall" ) func mai
【后端编程】使用go语言实现一个守护进程
青春不言败
12-07 2019
首先我们要知道 ①什么是守护进程;？ ②为什么要使用守护进程？ 答案： ①所谓守护进程，就是不依赖任何终端的进程，也就是说如果你在当前这个终端启动了一个守护进程，然后把这个终端关了。如果是一个普通进程，而不是守护进程，那么它也会随着终端的关闭而终止。但是守护进程就比较牛逼了，当你再次打开一个新的终端的时候，只要该守护进程的任务没有完成，那么你仍然可以看到它。 ②他有什么用呢？比如我正在做的服务端...
golang实现守护进程(3)—
dkjhl的博客
05-08 1855
在操作系统中，每个进程都有自己的进程ID(PID)，父进程ID(PPID)等信息。如果一个进程已经退出，但它的、它的资源和状态还留在系统中，这种进程被称为“僵尸进程”。僵尸进程不占用CPU时间和内存资源，但它们占用系统的进程表，因此可以说是一种资源泄漏。那么如何正确处理僵尸进程呢，golang语言中的os.exec包自带回收僵尸进程的处理逻辑，我们只要在子进程中添加对应的逻辑即可
golang实现守护进程(1)
dkjhl的博客
03-21 1171
golang实现守护进程，包含功能： 1. 守护进程只创建一次 2. 平滑创建业务进程 3. 业务进程挂起，守护进程能监听，并重启新启业务进程 4. 守护进程退出，也能保证业务进程退出 5. 业务进程≈子进程 6. 不影响业务进程逻辑 7. 以Linux平台为主，其他平台暂时没有实施条件
go 守护进程 业务进程 子进程 重启进程 系统信号
weixin_49497024的博客
10-07 720
业务进程 守护进程 子进程的关系，系统信号
GO语言实现的后台服务守护进程
07-22
/* 说明：本程序主要是实现Win32后台服务进程24小时监控, 当服务进程宕机后自动重启，并记录日志。 */ func main() { // 读取配置文件 iniConfig := new(util.Config) iniConfig.InitConfig("./server_daemon.ini") processName := iniConfig.Read("Monit","ProcessName") // 监控进程 programPath := iniConfig.Read("Monit","ProgramPath") // 启动路径 sleepTime := iniConfig.ReadInt("Monit", "SleepTime") // 轮询间隔 ...... 欲知代码详情请下载观看 }
如何让go程序以后台进程或daemon方式运行
一个从通信转行网络人的博客
08-17 843
网上找到了一个开源的库github.com/sevlyar/go-daemon，可以很方便保持参数不变另外启动一个后台进程，但如果后台进程再次尝试启动自身为另外一个后台进程，则会出现错误。其原理是利用的是exec.Cmd的Env属性设置子进程的环境变量时，添加一个特殊的环境变量，用以标记子程序。这种方案是入侵式的，新设置的参数，有可能和go程序原有参数冲突。最终决定自己实现一个库解决我项目中的需求，同时也期望它是一个很通用的库，可以快速方便把go语言编写的服务程序转为后台运行，或者转为守护进程的模式运行。
golang守护进程用法示例
09-21
主要介绍了golang守护进程用法,结合实例形式分析了Go语言守护进程的具体实现与使用技巧,需要的朋友可以参考下
go-daemon：用于在golang中编写系统守护程序的库
02-02
守护进程 用于在Go中编写系统守护程序的库。 现在仅支持基于UNIX的操作系统（不支持Windows）。 但是该库仅在Linux和OSX上进行了测试，因此，如果您有能力在其他平台上进行测试，请给我反馈（＃26）。 请随时向我...
go-crond:用golang编写的Cron守护程序（例如，在Docker映像中的用法）
05-04
用golang编写的cron守护程序 受启发 使用 Docker映像 在 webdevops/go-crond:alpine （基于alpine ） webdevops/go-crond:ubuntu （基于ubuntu:latest ） webdevops/go-crond:debian （基于debian:stable-slim ）...
golang 编程练习项目_Golang实现守护进程
weixin_39641334的博客
10-22 477
黑客技术点击右侧关注，了解黑客的世界！Linux编程点击右侧关注，免费入门到精通！https://mp.weixin.qq.com/s/bJWEg0A_t6e9k43YUnWrJA因为Golang没有Linux的fork()系统调用,所以实现守护进程要使用一些小技巧.Golang为*nix(unix/linux/FreeBSD...)系统提供了syscall.ForkExec()调用...
Golang创建守护进程
qq_41593652的博客
04-12 2037
一、 守护进程创建步骤 二、代码实现 func Daemon() { //父进程为init，已经是一个守护进程 if syscall.Getppid() == 1 { fmt.Println("process is already a daemon") } /* *fork 一个子进程 若成功pid在父进程中返回子进程号，在子进程中返回0 *其中syscall.Syscall函数为系统调用，内部实现为汇编语言 *推测函数四个入参为：第一个是系统函.
Golang 中创建守护进程的正确姿势
Qiangks的博客
01-09 9045
一直对守护进程有点迷糊， Srs的守护进程是通过两次fork实现的。 C/C++一般的做法是fork一次， 然后调用setsid() 实现daemon， golang呢？ 守护进程的特点 守护进程： 我的理解是脱离控制台的进程。 一般我们执行程序都是在shell/bash下启动程序， 如果不以守护进程方式启动，该程序的父进程一般就是bash或shell， 通过ps -ef | grep xxx...
Go+ 信号处理教程（4.27）
liuzhen007的专栏
12-04 818
Go+ 概述 Go+ 是一门融合工程开发的 Go、数据科学领域的 Python、编程教学领域的 Scratch，以 Python 之形结合 Go 之心，让工程师处理数据不需要学习新的开发语言，让初学者学习编程、开发作品的门槛更低的编程语言。 正文 有时我们希望 Go+ 程序能够智能地处理信号。例如，服务器在收到 SIGTERM 信号时正常关闭，或者命令行工具在收到 SIGINT 信号时停止处理输入操作。Go+ 提供了信号处理的相关方法，今天我们就来了解一下这方面的一些内容。 导入包 Go+ 在处理
go 二进制程序守护_部署一个 Go 应用的正确姿势
weixin_39829166的博客
11-25 228
点击上方蓝色“Go语言中文网”关注我们，领全套Go资料，每天学习Go语言有些新手写完了他们的 Go 应用之后，这总会成为一个大问题——“我刚写的这个 Go 应用，当它崩溃的时候我要怎么重启？”，因为你没法用 go run main.go 或者 ./main 这样的命令让它持续运行，并且当程序崩溃的时候能够重启。一个普通使用的好办法是使用 Docker。但是，设置 Docker 以及为...
Airbyte分享
dkjhl的博客
07-06 5733
Airbyte，一家专注于 ELT 管道的开源数据集成平台，Airbyte 最主要的产品还是 Extract 数据抽取和 Load 数据加载产品。简单来说，就是利用连接器 (Connector) 连通多平台间的数据，其逻辑是平台连接的数据源越多，平台越稳定，而平台就会拥有壁垒。其次，Airbyte 也提供 Transform (数据转换) 产品，实际上 Transform 数据转换产品 Airbyte 也是集成了 Dbt 这样一个开源工具
Clickhouse物化视图原理和使用详解
dkjhl的博客
06-26 2470
ClickHouse是一个高性能、列式存储的分布式数据库管理系统，支持SQL查询、OLAP分析及实时数据处理等应用场景。其中，物化视图是ClickHouse中一项重要的功能，它能够提高查询性能，并且数据管理更加高效。本篇文章，我将从源码层面分析ClickHouse的物化视图的工作原理，使用场景和使用方式介绍clickhouse的物化视图，并比较oracle的视图进行分析
golang实现函数
最新发布
03-02
下面是介绍Golang实现函数的几个关键点： 1. 函数定义：使用关键字`func`来定义函数，语法如下： ``` func 函数名(参数列表) 返回值列表 { // 函数体 } ``` 例如，定义一个计算两个整数之和的函数： ``` ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

dkjhl

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值