Wie beende ich ein Go-Programm, um zurückgestellte Anrufe zu berücksichtigen?

Ich muss verwenden defer, um Zuordnungen freizugeben, die manuell mit der CBibliothek erstellt wurden, aber ich muss auch os.Exitirgendwann den Status ungleich 0 haben. Der schwierige Teil ist, dass os.Exitjede zurückgestellte Anweisung übersprungen wird:

package main

import "fmt"
import "os"

func main() {

    // `defer`s will _not_ be run when using `os.Exit`, so
    // this `fmt.Println` will never be called.
    defer fmt.Println("!")
    // sometimes ones might use defer to do critical operations
    // like close a database, remove a lock or free memory

    // Exit with status code.
    os.Exit(3)
}

Spielplatz: http://play.golang.org/p/CDiAh9SXRM gestohlen von https://gobyexample.com/exit

Wie kann man ein Go-Programm beenden, das deklarierte deferAnrufe berücksichtigt? Gibt es eine Alternative zu os.Exit?

runtime.Goexit() ist der einfache Weg, dies zu erreichen.

Goexit beendet die Goroutine, die es aufruft. Keine andere Goroutine ist betroffen. Goexit führt alle zurückgestellten Anrufe aus, bevor die Goroutine beendet wird. Da Goexit jedoch nicht in Panik gerät, geben alle Wiederherstellungsaufrufe in diesen verzögerten Funktionen null zurück.

Jedoch:

Wenn Sie Goexit von der Haupt-Goroutine aus aufrufen, wird diese Goroutine beendet, ohne dass die Haupt-Goroutine zurückkehrt. Da func main nicht zurückgekehrt ist, setzt das Programm die Ausführung anderer Goroutinen fort. Wenn alle anderen Goroutinen beendet werden, stürzt das Programm ab.

Wenn Sie es also von der Hauptgoroutine aus aufrufen, mainmüssen Sie oben hinzufügen

defer os.Exit(0)

Darunter möchten Sie möglicherweise einige andere deferAnweisungen hinzufügen , die die anderen Goroutinen anweisen, anzuhalten und aufzuräumen.

Bewegen Sie Ihr Programm einfach um eine Ebene nach unten und geben Sie Ihren Exit-Code zurück:

package main

import "fmt"
import "os"

func doTheStuff() int {
    defer fmt.Println("!")

    return 3
}

func main() {
    os.Exit(doTheStuff())
}

Nach einigen Recherchen auf diese verweisen dies , fand ich eine Alternative , dass:

• Erzwingt keine bestimmte Architektur wie in https://stackoverflow.com/a/27629493/438563
• Erfordert keinen globalen Wert wie in https://stackoverflow.com/a/24601700/438563

Wir können die Vorteile der panicund recover. Es stellt sich heraus, dass Anrufe panicvon Natur aus deferhonoriert werden, aber auch immer mit einem Nicht- 0Statuscode beendet werden und eine Stapelverfolgung ausgegeben wird. Der Trick ist, dass wir den letzten Aspekt des Panikverhaltens überschreiben können mit:

package main

import "fmt"
import "os"

type Exit struct{ Code int }

// exit code handler
func handleExit() {
    if e := recover(); e != nil {
        if exit, ok := e.(Exit); ok == true {
            os.Exit(exit.Code)
        }
        panic(e) // not an Exit, bubble up
    }
}

Um ein Programm zu einem beliebigen Zeitpunkt deferzu beenden und dennoch alle deklarierten Anweisungen beizubehalten, müssen Sie nur einen ExitTyp ausgeben :

func main() {
    defer handleExit() // plug the exit handler
    defer fmt.Println("cleaning...")
    panic(Exit{3}) // 3 is the exit code
}

Es ist kein Refactoring erforderlich, außer dass eine Leitung eingesteckt wird func main:

func main() {
    defer handleExit()
    // ready to go
}

Dies lässt sich mit größeren Codebasen recht gut skalieren, sodass ich es zur Überprüfung zur Verfügung stellen werde. Ich hoffe es hilft.

Spielplatz: http://play.golang.org/p/4tyWwhcX0-

Für die Nachwelt war dies für mich eine elegantere Lösung:

func main() { 
    retcode := 0
    defer func() { os.Exit(retcode) }()
    defer defer1()
    defer defer2()

    [...]

    if err != nil {
        retcode = 1
        return
    }
}

Ich würde vorschlagen, eine Goroutine zu verwenden

func main(){
     fmt.Println("Hello world")
     go func(){
          os.Exit(0)
     }
}