Ist es möglich, ein Strg + C-Signal zu erfassen und eine Bereinigungsfunktion auf "verzögerte" Weise auszuführen?

Ich möchte das von der Konsole gesendete Ctrl+C( SIGINT) Signal erfassen und einige Teillaufsummen ausdrucken.

Ist das in Golang möglich?

Hinweis: Als ich die Frage zum ersten Mal stellte, war ich verwirrt darüber Ctrl+C, SIGTERMstatt zu sein SIGINT.

Sie können das Betriebssystem- / Signalpaket verwenden , um eingehende Signale zu verarbeiten. Ctrl+ Cist SIGINT , daher können Sie dies zum Einfangen verwenden os.Interrupt.

c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
go func(){
    for sig := range c {
        // sig is a ^C, handle it
    }
}()

Die Art und Weise, wie Sie Ihr Programm beenden und Informationen drucken lassen, liegt ganz bei Ihnen.

Das funktioniert:

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
    "time" // or "runtime"
)

func cleanup() {
    fmt.Println("cleanup")
}

func main() {
    c := make(chan os.Signal)
    signal.Notify(c, os.Interrupt, syscall.SIGTERM)
    go func() {
        <-c
        cleanup()
        os.Exit(1)
    }()

    for {
        fmt.Println("sleeping...")
        time.Sleep(10 * time.Second) // or runtime.Gosched() or similar per @misterbee
    }
}

Um die anderen Antworten etwas zu ergänzen, können Sie syscall.SIGTERManstelle von os.Interrupt SIGTERM (das vom Befehl kill gesendete Standardsignal) abfangen. Beachten Sie, dass die Syscall-Schnittstelle systemspezifisch ist und möglicherweise nicht überall funktioniert (z. B. unter Windows). Aber es funktioniert gut, beides zu fangen:

c := make(chan os.Signal, 2)
signal.Notify(c, os.Interrupt, syscall.SIGTERM)
....

Die oben akzeptierte Antwort enthielt (zum Zeitpunkt der Veröffentlichung) ein oder zwei kleine Tippfehler. Hier ist also die bereinigte Version. In diesem Beispiel stoppe ich den CPU-Profiler beim Empfang von Ctrl+ C.

// capture ctrl+c and stop CPU profiler                            
c := make(chan os.Signal, 1)                                       
signal.Notify(c, os.Interrupt)                                     
go func() {                                                        
  for sig := range c {                                             
    log.Printf("captured %v, stopping profiler and exiting..", sig)
    pprof.StopCPUProfile()                                         
    os.Exit(1)                                                     
  }                                                                
}()    

Alle oben genannten Punkte scheinen zu funktionieren, wenn sie zusammengefügt werden, aber die Signalseite von gobyexample enthält ein wirklich sauberes und vollständiges Beispiel für die Signalerfassung. Es lohnt sich, diese Liste zu ergänzen.

Death ist eine einfache Bibliothek, die Kanäle und eine Wartegruppe verwendet, um auf Abschaltsignale zu warten. Sobald das Signal empfangen wurde, ruft es eine close-Methode für alle Ihre Strukturen auf, die Sie bereinigen möchten.

Sie können eine andere Goroutine verwenden, die syscall.SIGINT- und syscall.SIGTERM-Signale erkennt und diese mithilfe von signal.Notify an einen Kanal weiterleitet . Sie können einen Hook über einen Kanal an diese Goroutine senden und in einem Funktions-Slice speichern. Wenn das Abschaltsignal auf dem Kanal erkannt wird, können Sie diese Funktionen im Slice ausführen. Dies kann verwendet werden, um die Ressourcen zu bereinigen, auf das Ausführen von Goroutinen zu warten, Daten beizubehalten oder Teillaufsummen zu drucken.

Ich habe ein kleines und einfaches Dienstprogramm geschrieben, um beim Herunterfahren Hooks hinzuzufügen und auszuführen. Hoffe es kann hilfreich sein.

https://github.com/ankit-arora/go-utils/blob/master/go-shutdown-hook/shutdown-hook.go

Sie können dies auf eine "verzögerte" Weise tun.

Beispiel für das ordnungsgemäße Herunterfahren eines Servers:

srv := &http.Server{}

go_shutdown_hook.ADD(func() {
    log.Println("shutting down server")
    srv.Shutdown(nil)
    log.Println("shutting down server-done")
})

l, err := net.Listen("tcp", ":3090")

log.Println(srv.Serve(l))

go_shutdown_hook.Wait()

Dies ist eine andere Version, die funktioniert, wenn Sie einige Aufgaben bereinigen müssen. Der Code verlässt den Bereinigungsprozess in seiner Methode.

package main

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

)



func main() {

    _,done1:=doSomething1()
    _,done2:=doSomething2()

    //do main thread


    println("wait for finish")
    <-done1
    <-done2
    fmt.Print("clean up done, can exit safely")

}

func doSomething1() (error, chan bool) {
    //do something
    done:=make(chan bool)
    c := make(chan os.Signal, 2)
    signal.Notify(c, os.Interrupt, syscall.SIGTERM)
    go func() {
        <-c
        //cleanup of something1
        done<-true
    }()
    return nil,done
}


func doSomething2() (error, chan bool) {
    //do something
    done:=make(chan bool)
    c := make(chan os.Signal, 2)
    signal.Notify(c, os.Interrupt, syscall.SIGTERM)
    go func() {
        <-c
        //cleanup of something2
        done<-true
    }()
    return nil,done
}

Wenn Sie die Hauptfunktion bereinigen müssen, müssen Sie das Signal im Hauptthread auch mit go func () erfassen.

Nur zur Veranschaulichung, wenn jemand eine Möglichkeit benötigt, Signale unter Windows zu verarbeiten. Ich hatte die Anforderung, von Prog A, das Prog B aufruft, über OS / Exec zu kommen, aber Prog B konnte nie ordnungsgemäß beendet werden, da Signale über Ex gesendet wurden. cmd.Process.Signal (syscall.SIGTERM) oder andere Signale werden unter Windows nicht unterstützt. Ich habe damit umgegangen, indem ich eine temporäre Datei als Signal erstellt habe. .signal.term durch Prog A und Prog B muss überprüfen, ob diese Datei auf Intervallbasis vorhanden ist. Wenn eine Datei vorhanden ist, wird das Programm beendet und bei Bedarf bereinigt. Ich bin sicher, dass es andere Möglichkeiten gibt, aber dies hat den Job erledigt.