在Golang中：防止子进程接收来自调用进程的信号

Question

以下是给定代码：

package main
import (
    "os"
    "fmt"
    "os/exec"
    "os/signal"
    "syscall"
)

const NUMBER_OF_PEASANTS = 3

func createPeasants() map[string]*exec.Cmd {
    peasants := map[string]*exec.Cmd{}
    for i := 0; i < NUMBER_OF_PEASANTS; i++ {
        name := fmt.Sprintf("peasant#%d", i + 1)
        fmt.Printf("[master] Start %s...\n", name)
        cmd := exec.Command(os.Args[0], name)
        cmd.Stderr = os.Stderr
        cmd.Stdin = os.Stdin
        cmd.Stdout = os.Stdout
        if err := cmd.Start(); err != nil {
            panic(err)
        }
        peasants[name] = cmd
    }
    return peasants
}

func masterWaitForSignal(c chan os.Signal) {
    for true {
        s := <-c
        fmt.Printf("[master] Got signal %v but still running...\n", s)
    }
}

func peasantWaitForSignal(name string, c chan os.Signal) {
    s := <-c
    fmt.Printf("[%s] Got signal %v and will exit not with code 66\n", name, s)
    os.Exit(66)
}

func waitForPeasants(peasants map[string]*exec.Cmd) {
    for name, peasant := range peasants {
        if err := peasant.Wait(); err != nil {
            if exitError, ok := err.(*exec.ExitError); ok {
                waitStatus := exitError.Sys().(syscall.WaitStatus)
                fmt.Printf("[master] %s ended with exit code %d.\n", name, waitStatus.ExitStatus())
            } else {
                panic(err)
            }
        }
    }
}

func actAsMaster() {
    c := make(chan os.Signal, 1)
    signal.Notify(c, os.Interrupt)

    peasants := createPeasants()

    fmt.Printf("[master] Started.\n")
    go masterWaitForSignal(c)
    waitForPeasants(peasants)
    fmt.Printf("[master] Done.\n")
}

func actAsPeasant(name string) {
    c := make(chan os.Signal, 1)
    signal.Notify(c, os.Interrupt)

    fmt.Printf("[%s] Started.\n", name)
    peasantWaitForSignal(name, c)
    fmt.Printf("[%s] Done.\n", name)
}

func main() {
    if len(os.Args) > 1 {
        actAsPeasant(os.Args[1])
    } else {
        actAsMaster()
    }
}

当我运行代码并在其运行时按下[Ctrl]+[C]时，会产生以下输出：

$ go run signaldemo.go 
[master] Start peasant#1...
[master] Start peasant#2...
[master] Start peasant#3...
[peasant#1] Started.
[master] Started.
[peasant#2] Started.
[peasant#3] Started.
^C[peasant#2] Got signal interrupt and will exit not with code 66
[peasant#1] Got signal interrupt and will exit not with code 66
[master] Got signal interrupt but still running...
[master] peasant#1 ended with exit code 66.
[master] peasant#2 ended with exit code 66.
[peasant#3] Got signal interrupt and will exit not with code 66
[master] peasant#3 ended with exit code 66.
[master] Done.

我该怎么样防止子进程收到中断信号？但是我不想重写子进程。需要改变调用进程。

- GreNodge

Answer 1

默认情况下，子进程在同一进程组中启动，当按下ctrl+c时，您的shell会向所有进程发送信号。这是shell的默认行为，以尝试在中断程序时进行清理。

子进程不会接收到直接发送给父进程的信号。

如果要防止ctrl+c行为，则可以使用syscall.SysProcAttr中的Setpgid和Pgid字段强制子进程在自己的进程组中启动，然后再启动进程。

cmd.SysProcAttr = &syscall.SysProcAttr{
    Setpgid: true,
    Pgid:    0,
}

- JimB

---

这在Linux上运行得非常完美。我能期望以下代码在Windows上也能做到同样的效果吗？ cmd.SysProcAttr = &syscall.SysProcAttr{ CreationFlags: 0x00000008, }请参考以下链接列出的代码：https://msdn.microsoft.com/en-us/library/windows/desktop/ms684863(v=vs.85).aspx - GreNodge

@GreNodge：我不知道Windows的情况，但那听起来似乎不是同一件事（尽管它可能做到你想要的）。syscall.CREATE_NEW_PROCESS_GROUP的描述与POSIX setpgid相似。 - JimB

我两种都尝试了。两种都似乎都按预期工作。但是我同意您的看法，syscall.CREATE_NEW_PROCESS_GROUP 似乎是更好的匹配类型。谢谢您的支持。 - GreNodge

请注意，此选项会导致docker-compose进程挂起。...仍在调查中，但删除attrs有助于解决问题。 - Brun