子进程接收到只能由父进程处理的 SIGINT，导致子进程突然终止

Question

我正在尝试使用 stdpipes 在 golang 中管理一个应用程序（需要通过特定程序关闭，在本例中是拯救世界）。
这是我要实现的目标的一个简单例子，但我有一个问题，这对我来说非常具体，但对其他人来说也可能很有趣（也许你可以建议如何概括它）。

我还添加了一个名为 interruptListener 的函数，它创建一个 goroutine 并在发送 kill 信号时管理程序的停止

脚本的正常功能:

启动我的世界服务器
等待 40 秒，然后通过 std 发出“停止”命令
（在这种情况下，它按预期打印有关保存过程的所有日志）

测试用例（演示问题出在哪里）：

启动我的世界服务器
在脚本发出停止命令之前用户发送 ctrl+c
（在这种情况下，它应该完成打印有关保存过程的日志然后退出，但它没有......似乎在收到终止信号后 scanner.Scan() returns false 所以它只是退出）

您知道为什么会发生这种情况吗？我应该研究什么才能找到解决方案？

我真的迷路了我已经花了 8 个多小时来研究所有可能的代码组合...

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
    "os/exec"
    "os/signal"
    "strings"
    "sync"
    "syscall"
    "time"
)

var cmd *exec.Cmd

var wg sync.WaitGroup

var stdOut io.ReadCloser
var stdErr io.ReadCloser
var stdIn io.WriteCloser

func main() {
    interruptListener()

    cSplit := strings.Split("java -Xmx1024M -Xms1024M -jar server.jar nogui", " ")
    cmd = exec.Command(cSplit[0], cSplit[1:]...)
    cmd.Dir = "path/to/server/folder"
    stdOut, _ = cmd.StdoutPipe()
    stdErr, _ = cmd.StderrPipe()
    stdIn, _ = cmd.StdinPipe()
    wg.Add(2)
    go printer(stdOut)
    go printer(stdErr)
    err := cmd.Start()
    if err != nil {
        fmt.Println(err)
    }

    // test 1: wait 40 seconds for it to send the stop command and observe the output
    // test 2: in the 40 seconds (after the server has loaded press ctrl+c), there is no output
    time.Sleep(40 * time.Second)
    execute("stop")

    err = cmd.Wait()
    if err != nil {
        fmt.Println(err.Error())
    }
}

func printer(stdP io.ReadCloser) {
    defer func() {
        wg.Done()
        fmt.Println("printer is out")
    }()

    var line string

    scanner := bufio.NewScanner(stdP)

    for scanner.Scan() {
        line = scanner.Text()

        fmt.Println(line)
    }

    fmt.Printf("scanner error: %v\n", scanner.Err())
}

func execute(com string) {
    fmt.Println("sending", com, "to terminal")

    // needs to be added otherwise the virtual "enter" button is not pressed
    com += "\n"

    // write to cmd
    _, err := stdIn.Write([]byte(com))
    if err != nil {
        fmt.Println(err.Error())
    }
}

func interruptListener() {
    c := make(chan os.Signal, 1)
    signal.Notify(c, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
    go func() {
        select {
        case <-c:
            execute("stop")
            wg.Wait()
            os.Exit(0)
        }
    }()
}

Answer 1

感谢在评论中回答的人，这是一个可以接受的解决方案（如评论中所述，仍然不完美）

在执行之前添加这几行 cmd.Start():

    // launch as new process group so that signals (ex: SIGINT) are not sent also the the child process
    cmd.SysProcAttr = &syscall.SysProcAttr{
        CreationFlags: syscall.CREATE_NEW_PROCESS_GROUP, // windows
        // Setpgid: true, // linux
    }

Answer 2

这里有一个更完整的问题答案 - Killing a child process and all of its children in Go

子进程接收到只能由父进程处理的 SIGINT，导致子进程突然终止

child process receives SIGINT which should be handled only by parent process, resulting in abrupt termination of child

signals

stdout

go