Unix-Signale in Go behandeln

Einführung

Das Signals Lab zeigt, wie man in Go-Programmen mit Kanälen Unix-Signale behandelt.

Signale

In einigen Fällen möchten wir, dass unsere Go-Programme Unix-Signale intelligent behandeln. Beispielsweise möchten wir, dass ein Server sich bei Empfang eines SIGTERM gnädig beendet, oder dass ein Befehlszeilentool die Eingabeverarbeitung stoppt, wenn es ein SIGINT erhält.

• Erstellen Sie einen gepufferten Kanal, um os.Signal-Benachrichtigungen zu empfangen.
• Registrieren Sie den Kanal, um Benachrichtigungen über bestimmte Signale mithilfe von signal.Notify zu erhalten.
• Erstellen Sie eine Goroutine, um einen blockierenden Empfang von Signalen auszuführen.
• Geben Sie das empfangene Signal aus und benachrichtigen Sie das Programm, dass es beendet werden kann.
• Warten Sie auf das erwartete Signal und beenden Sie dann das Programm.

## Wenn wir dieses Programm ausführen, wird es blockieren und auf ein
## Signal warten. Indem wir `ctrl-C` eingeben (was der
## Terminal als `^C` anzeigt), können wir ein `SIGINT`-Signal senden,
## was das Programm veranlasst, `interrupt` auszugeben und dann zu beenden.
$ go run signals.go
awaiting signal
^C
interrupt
exiting

Hier ist der vollständige Code:

// Manchmal möchten wir, dass unsere Go-Programme intelligent
// [Unix-Signale](https://en.wikipedia.org/wiki/Unix_signal) behandeln.
// Beispielsweise möchten wir, dass ein Server sich bei Empfang eines `SIGTERM` gnädig beendet,
// oder dass ein Befehlszeilentool die Eingabeverarbeitung stoppt, wenn es ein `SIGINT` erhält.
// Hier ist, wie man Signale in Go mit Kanälen behandelt.

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
)

func main() {

    // Die Go-Signalbenachrichtigung funktioniert, indem `os.Signal`-
    // Werte über einen Kanal gesendet werden. Wir werden einen Kanal
    // erstellen, um diese Benachrichtigungen zu empfangen. Beachten Sie,
    // dass dieser Kanal gepuffert sein sollte.
    sigs := make(chan os.Signal, 1)

    // `signal.Notify` registriert den angegebenen Kanal, um
    // Benachrichtigungen über die angegebenen Signale zu erhalten.
    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

    // Wir könnten hier im Hauptprogramm von `sigs` empfangen,
    // aber sehen wir uns an, wie dies auch in einer separaten Goroutine
    // geschehen könnte, um ein realistischeres Szenario der gnädigen Beendigung zu demonstrieren.
    done := make(chan bool, 1)

    go func() {
        // Diese Goroutine führt einen blockierenden Empfang von
        // Signalen aus. Wenn sie eines erhält, wird es ausgegeben
        // und dann das Programm benachrichtigt, dass es beendet werden kann.
        sig := <-sigs
        fmt.Println()
        fmt.Println(sig)
        done <- true
    }()

    // Das Programm wird hier warten, bis es das erwartete Signal erhält
    // (wie durch die obige Goroutine angedeutet, indem ein Wert auf `done` gesendet wird)
    // und wird dann beendet.
    fmt.Println("awaiting signal")
    <-done
    fmt.Println("exiting")
}

Zusammenfassung

Das Signals Lab zeigt, wie man in Go-Programmen mit Kanälen Unix-Signale behandelt. Indem man einen gepufferten Kanal zur Empfang von os.Signal-Benachrichtigungen erstellt und den Kanal zur Empfang von Benachrichtigungen über bestimmte Signale mit signal.Notify registriert, kann man Signale gnädig behandeln und das Programm beenden, wenn das erwartete Signal empfangen wird.