如何避免 Go 命令行執行產生 “孤兒” 進程？

在 Go 程序當中，如果我們要執行命令時，通常會使用 exec.Command ，也比較好用，通常狀況下，可以達到我們的目的，如果我們邏輯當中，需要終止這個進程，則可以快速使用 cmd.Process.Kill() 方法來結束進程。但當我們要執行的命令會啓動其他子進程來操作的時候，會發生什麼情況？

一孤兒進程的產生

測試小程序：

func kill(cmd *exec.Cmd) func() {
    return func() {
    if cmd != nil {
    cmd.Process.Kill()
    }
    }
}
func main() {
    cmd := exec.Command("/bin/bash", "-c", "watch top >top.log")
    time.AfterFunc(1*time.Second, kill(cmd))
    err := cmd.Run()
    fmt.Printf("pid=%d err=%s\n", cmd.Process.Pid, err)
}

執行小程序：

go run main.go
pid=27326 err=signal: killed

查看進程信息：

ps -j
USER    PID  PPID  PGID   SESS JOBC STAT   TT       TIME COMMAND
king  24324     1 24303      0    0 S    s012    0:00.01 watch top

可以看到這個 "watch top" 的 PPID 爲 1，說明這個進程已經變成了 “孤兒” 進程。

那爲什麼會這樣，這並不符合我們預期，那麼可以從 Go 的文檔中找到答案：

二通過進程組來解決掉所有子進程

在 linux 當中，是有會話、進程組和進程組的概念，並且 Go 也是使用 linux 的 kill(2) 方法來發送信號的，那麼是否可以通過 kill 來將要結束進程的子進程都結束掉？

linux 的 kill(2) 的定義如下：

#include <signal.h>
int kill(pid_t pid, int sig);

並在方法的描述中，可以看到如下內容：

如果 pid 爲正數的時候，會給指定的 pid 發送 sig 信號，如果 pid 爲負數的時候，會給這個進程組發送 sig 信號，那麼我們可以通過進程組來將所有子進程退出掉？改一下 Go 程序中 kill 方法：

func kill(cmd *exec.Cmd) func() {
    return func() {
    if cmd != nil {
    // cmd.Process.Kill()
    syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
    }
    }
}
func main() {
    cmd := exec.Command("/bin/bash", "-c", "watch top >top.log")
    time.AfterFunc(1*time.Second, kill(cmd))
    err := cmd.Run()
    fmt.Printf("pid=%d err=%s\n", cmd.Process.Pid, err)
}

再次執行：

go run main.go

會發現程序卡住了，我們來看一下當前執行的進程：

ps -j
USER    PID  PPID  PGID   SESS JOBC STAT   TT       TIME COMMAND
king 27655 91597 27655      0    1 S+   s012    0:01.10 go run main.go
king 27672 27655 27655      0    1 S+   s012    0:00.03 ..../exe/main
king 27673 27672 27655      0    1 S+   s012    0:00.00 /bin/bash -c watch top >top.log
king 27674 27673 27655      0    1 S+   s012    0:00.01 watch top

可以看到我們 go run 產生了一個子進程 27672（command 那裏是 go 執行的臨時目錄，比較長，因此添加了省略號），27672 產生了 27673（watch top >top.log）進程，27673 產生了 27674（watch top）進程。那爲什麼沒有將這些子進程都關閉掉呢？

其實之類犯了一個低級錯誤，從上圖中，我們可以看到他們的進程組 ID 爲 27655，但是我們傳遞的是 cmd 的 id 即 27673，這個並不是進程組的 ID，因此程序並沒有 kill，導致 cmd.Run() 一直在執行。

在 Linux 中，進程組中的第一個進程，被稱爲進程組 Leader，同時這個進程組的 ID 就是這個進程的 ID，從這個進程中創建的其他進程，都會繼承這個進程的進程組和會話信息；從上面可以看出 go run main.go 程序 PID 和 PGID 同爲 27655，那麼這個進程就是進程組 Leader，我們不能 kill 這個進程組，除非想 “自殺”，哈哈哈。

那麼我們給要執行的進程，新建一個進程組，在 Kill 不就可以了嘛。在 linux 當中，通過 setpgid 方法來設置進程組 ID，定義如下：

#include <unistd.h>
int setpgid(pid_t pid, pid_t pgid);

如果將 pid 和 pgid 同時設置成 0，也就是 setpgid(0,0)，則會使用當前進程爲進程組 leader 並創建新的進程組。

那麼在 Go 程序中，可以通過 cmd.SysProcAttr 來設置創建新的進程組，修改後的代碼如下：

func kill(cmd *exec.Cmd) func() {
    return func() {
    if cmd != nil {
    // cmd.Process.Kill()
    syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
    }
    }
}
func main() {
    cmd := exec.Command("/bin/bash", "-c", "watch top >top.log")
  cmd.SysProcAttr = &syscall.SysProcAttr{
    Setpgid: true,
    }
    time.AfterFunc(1*time.Second, kill(cmd))
    err := cmd.Run()
    fmt.Printf("pid=%d err=%s\n", cmd.Process.Pid, err)
}

再次執行：

go run main.go
pid=29397 err=signal: killed

再次查看進程：

ps -j
USER    PID  PPID  PGID   SESS JOBC STAT   TT       TIME COMMAND

發現 watch 的進程都不存在了，那我們在看看是否還會有孤兒進程：

# 由於我測試的環境是mac，因此這個腳本只能在mac執行
ps -j | head -1;ps -j | awk '{if ($3 ==1 && $1 !="root"){print $0}}' | head
USER    PID  PPID  PGID   SESS JOBC STAT   TT       TIME COMMAND

已經沒有孤兒進程了，問題至此已經完全解決。

三子進程監聽父進程是否退出 (只能在 linux 下執行)

假設要調用的程序也是我們自己寫的其他應用程序，那麼可以使用 Linux 的 prctl 方法來處理， prctl 方法的定義如下：

#include <sys/prctl.h>
int prctl(int option, unsigned long arg2, unsigned long arg3,
          unsigned long arg4, unsigned long arg5);

這個方法有一個重要的 option：PR_SET_PDEATHSIG，通過這個來接收父進程的退出。

讓我們來再次構造一個有問題的程序。

有兩個文件，分別爲 main.go 和 child.go 文件，main.go 會調用 child.go 文件。

main.go 文件：

package main
import (
        "os/exec"
)
func main() {
        cmd := exec.Command("./child")
        cmd.Run()
}

child.go 文件：

package main
import (
    "fmt"
    "time"
)
func main() {
    for {
    time.Sleep(200 * time.Millisecond)
    fmt.Println(time.Now())
    }
}

在 Linux 環境中分別編譯這兩個文件：

// 編譯 main.go 生成 main 二進制文件
go build -o main main.go
// 編譯 child.go 生成 child 二進制文件
go build -o child child.go

執行 main 二進制文件：

./main &

查看他們的進程：

ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 06:05 pts/0    00:00:00 /bin/bash
root     11514     1  0 12:12 pts/0    00:00:00 ./main
root     11520 11514  0 12:12 pts/0    00:00:00 ./child

可以看到 main 和 child 的進程，child 是 main 的子進程，我們將 main 進程 kill 掉，在查看進程狀態：

kill -9 11514
ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 06:05 pts/0    00:00:00 /bin/bash
root     11520     1  0 12:12 pts/0    00:00:00 ./child

我們可以看到 child 的進程，他的 PPID 已經變成了 1，說明這個進程已經變成了孤兒進程。

那接下來我們可以使用 PR_SET_PDEATHSIG 來保證父進程退出，子進程也退出，大致方式有兩種：使用 CGO 調用和使用 syscall.RawSyscall 來調用。

1 使用 CGO

將 child 修改成如下內容：

import (
    "fmt"
    "time"
)
// #include <stdio.h>
// #include <stdlib.h>
// #include <sys/prctl.h>
// #include <signal.h>
//
// static void killTest() {
//    prctl(PR_SET_PDEATHSIG,SIGKILL);
// }
import "C"
func main() {
    C.killTest()
    for {
    time.Sleep(200 * time.Millisecond)
    fmt.Println(time.Now())
    }
}

程序中，使用 CGO，爲了簡單的展示，在 Go 文件中編寫了 C 的 killTest 方法，並調用了 prctl 方法，然後在 Go 程序中調用 killTest 方法，讓我們重新編譯執行一下，再看看進程：

go build -o child child.go
./main & 
ps -ef 
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 06:05 pts/0    00:00:00 /bin/bash
root     11663     1  0 12:28 pts/0    00:00:00 ./main
root     11669 11663  0 12:28 pts/0    00:00:00 ./child

再次 kill 掉 main，並查看進程：

kill -9 11663
ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 06:05 pts/0    00:00:00 /bin/bash

可以看到 child 的進程也已經退出了，說明 CGO 調用的 prctl 生效了。

2 syscall.RawSyscall 方法

也可以採用 Go 中提供的 syscall.RawSyscall 方法來替代調用 CGO，在 Go 的文檔中，可以查看到 syscall 包中定義的常量（查看 linux，如果是本地 godoc，需要指定 GOOS=linux），可以看到我們要用的幾個常量以及他們對應的數值：

// 其他內容省略掉了
const(
    ....
    PR_SET_PDEATHSIG                 = 0x1
    ....
)
const(     
    .....
    SYS_PRCTL                  = 157
    .....
)

其中 PR_SET_PDEATHSIG 操作的值爲 1，SYS_PRCTL 的值爲 157，那麼將 child.go 修改成如下內容：

package main
import (
    "fmt"
    "os"
    "syscall"
    "time"
)
func main() {
    _, _, errno := syscall.RawSyscall(uintptr(syscall.SYS_PRCTL), uintptr(syscall.PR_SET_PDEATHSIG), uintptr(syscall.SIGKILL), 0)
    if errno != 0 {
    os.Exit(int(errno))
    }
    for {
    time.Sleep(200 * time.Millisecond)
    fmt.Println(time.Now())
    }
}

再次編譯並執行：

go build -o child child.go
./main & 
ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 06:05 pts/0    00:00:00 /bin/bash
root     12208     1  0 12:46 pts/0    00:00:00 ./main
root     12214 12208  0 12:46 pts/0    00:00:00 ./child

將 main 進程結束掉：

kill -9 12208
ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 06:05 pts/0    00:00:00 /bin/bash

child 進程已經退出了，也達成了最終效果。

四總結

當我們使用 Go 程序執行其他程序的時候，如果其他程序也開啓了其他進程，那麼在 kill 的時候可能會把這些進程變成孤兒進程，一直執行並滯留在內存中。當然，如果我們程序非法退出，或者被 kill 調用，也會導致我們執行的進程變成孤兒進程，那麼爲了解決這個問題，從兩個思路來解決：

給要執行的程序創建新的進程組，並調用 syscall.Kill，傳遞負值 pid 來關閉這個進程組中所有的進程（比較完美的解決方法）。
如果要調用的程序也是我們自己編寫的，那麼可以使用 PR_SET_PDEATHSIG 來感知父進程退出，那麼這種方式需要調用 Linxu 的 prctrl，可以使用 CGO 的方式，也可以使用 syscall.RawSyscall 的方式。

但不管使用哪種方式，都只是提供了一種思路，在我們編寫服務端服務程序的時候，需要特殊關注，防止孤兒進程消耗服務器資源。

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/MJKlUBF9_vpGt2z9r7WjsA

猜你喜歡