Início / coding / Perguntas / 79540817
Accepted
Colder
Asked: 2025-03-28 15:52:25 +0800 CST

Como encerrar um processo no Windows de forma semelhante ao SIGTERM?

  • 772

Quero sair do processo de destino graciosamente em vez de encerrá-lo diretamente. O processo A envia um comando para o processo B e, após recebê-lo, B completará suas tarefas de limpeza e então sairá.

  1. O processo de destino não é um programa de console, então não posso usar windows.GenerateConsoleCtrlEvent.
  2. O processo de destino não é uma interface gráfica, então não posso usar WM_CLOSE.

O Killmétodo no ospacote Golang na verdade usa TerminateProcess, o que não é o que eu quero.

Atualizar:

  1. Tentei fazer o processo alvo escutar stdin. O subprocesso começou e então terminou imediatamente. Parece que isso não funciona no modo não interativo. 
    if runtime.GOOS == "windows" {
    reader := bufio.NewReader(os.Stdin)
    if _, err := reader.ReadString('\n'); err != nil {
        stop()
    }
}
  2. Eu tentei usar taskkill /t, mas ele me disse que o processo alvo é um processo filho de outro processo. Então eu ajustei o relacionamento pai-filho e fiz o processo pai chamar taskkill /t, mas ele ainda retornou o erro Exit status 128. Isso é muito estranho.

Finalmente:

No final, resolvi o problema usando pipes nomeados. A desvantagem é que ele requer suporte no código do processo de destino. Mas isso é suficiente para mim porque o processo de destino não é de terceiros.

windows

2 respostas

  1. Quando não tiver certeza, recomendo olhar para aplicativos de código aberto bem conhecidos que tenham a funcionalidade que você deseja fazer. Como exemplo, o Air é um conhecido gerador de processos que monitora alterações de arquivo e reinicia aplicativos em caso de alteração. Eles implementam o processo start and kill assim:

    func (e *Engine) killCmd(cmd *exec.Cmd) (pid int, err error) {
    pid = cmd.Process.Pid
    // https://stackoverflow.com/a/44551450
    kill := exec.Command("TASKKILL", "/T", "/F", "/PID", strconv.Itoa(pid))

    if e.config.Build.SendInterrupt {
        if err = kill.Run(); err != nil {
            return
        }
        time.Sleep(e.config.killDelay())
    }
    err = kill.Run()
    // Wait releases any resources associated with the Process.
    _, _ = cmd.Process.Wait()
    return pid, err
}

func (e *Engine) startCmd(cmd string) (*exec.Cmd, io.ReadCloser, io.ReadCloser, error) {
    var err error

    if !strings.Contains(cmd, ".exe") {
        e.runnerLog("CMD will not recognize non .exe file for execution, path: %s", cmd)
    }
    c := exec.Command("powershell", cmd)
    stderr, err := c.StderrPipe()
    if err != nil {
        return nil, nil, nil, err
    }
    stdout, err := c.StdoutPipe()
    if err != nil {
        return nil, nil, nil, err
    }

    c.Stdout = os.Stdout
    c.Stderr = os.Stderr

    err = c.Start()
    if err != nil {
        return nil, nil, nil, err
    }
    return c, stdout, stderr, err
}

    Você pode encontrar o repositório aqui

    Eles também fazem referência a outra postagem do Stack Overflow sobre o motivo pelo qual usam esse método específico.

    • 0
  2. Best Answer

    No final, resolvi o problema usando pipes nomeados.

    // target process main.go
func main() {
    // ... some logic 

    sig := make(chan os.Signal, 1)
    signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)

    if runtime.GOOS == "windows" {
        go func() {
            pipeName := fmt.Sprintf("\\\\.\\pipe\\%d", os.Getpid())
            listener, err := winio.ListenPipe(pipeName, nil)
            if err != nil {
                log.Errorf("Failed to create pipe: %v", err)
                return
            }
            defer listener.Close()

            conn, err := listener.Accept()
            if err != nil {
                log.Errorf("Pipe accept error: %v", err)
                return
            }
            defer conn.Close()

            buf := make([]byte, 1024)
            n, err := conn.Read(buf)
            if err != nil {
                log.Errorf("Pipe read error: %v", err)
            }
            msg := string(buf[:n])
            if msg == "shutdown" {
                sig <- syscall.SIGTERM
            }
        }()
    }
    
    <-sig
    stop()
}

    // control process
func killProcessGraceful(targetPID int) {
    pipeName := fmt.Sprintf(`\\.\pipe\%d`, targetPID)
    conn, err := winio.DialPipe(pipeName, nil)
    if err != nil {
        log.Errorf("Failed to connect to pipe (PID=%d): %v", targetPID, err)
        return killProcessForcefully(targetPID)
    }
    defer conn.Close()
    if _, err := conn.Write([]byte("shutdown")); err != nil {
        log.Errorf("Failed to send shutdown command: %v", err)
        return killProcessForcefully(targetPID)
    }

    return nil
}
    • 0

relate perguntas