Erlernen der defer Funktion in Golang

1 Einführung in das defer-Feature in Golang

In der Go-Sprache verzögert die defer-Anweisung den Aufruf der Funktion, die auf sie folgt, bis die Funktion, die die defer-Anweisung enthält, kurz vor dem Beenden der Ausführung steht. Man kann sie sich wie den finally-Block in anderen Programmiersprachen vorstellen, aber die Verwendung von defer ist flexibler und einzigartig.

Der Vorteil der Verwendung von defer besteht darin, dass sie zur Ausführung von Aufräumarbeiten wie dem Schließen von Dateien, dem Entfernen von Mutexen oder einfach dem Erfassen der Beendigungszeit einer Funktion verwendet werden kann. Dies kann das Programm robuster machen und die Menge der Programmierarbeit bei der Ausnahmebehandlung reduzieren. In der Designphilosophie von Go wird die Verwendung von defer empfohlen, da sie dazu beiträgt, den Code bei der Fehlerbehandlung, der Ressourcenfreigabe und anderen nachfolgenden Operationen knapp und lesbar zu halten.

2 Arbeitsprinzip von defer

2.1 Grundlegendes Arbeitsprinzip

Das grundlegende Arbeitsprinzip von defer besteht darin, einen Stapel (Last-in-First-out-Prinzip) zu verwenden, um jede ausstehende Funktion zu speichern, die ausgeführt werden soll. Wenn eine defer-Anweisung erscheint, führt die Go-Sprache die Funktion, die auf die Anweisung folgt, nicht unmittelbar aus. Stattdessen schiebt sie sie in einen dedizierten Stapel. Erst wenn die äußere Funktion kurz vor dem Rückgabewert steht, werden diese ausstehenden Funktionen in der Reihenfolge des Stapels ausgeführt, wobei die Funktion in der zuletzt deklarierten defer-Anweisung zuerst ausgeführt wird.

Es ist außerdem erwähnenswert, dass die Parameter in den Funktionen nach der defer-Anweisung zum Zeitpunkt der Deklaration von defer berechnet und festgelegt werden, anstatt bei der tatsächlichen Ausführung.

func beispiel() {
    defer fmt.Println("Welt") // ausstehend
    fmt.Println("Hallo")
}

func main() {
    beispiel()
}

Der obige Code gibt aus:

Hallo
Welt

Welt wird vor dem Verlassen der beispiel-Funktion gedruckt, obwohl es im Code vor Hallo steht.

2.2 Ausführungsreihenfolge von mehreren defer-Anweisungen

Wenn eine Funktion mehrere defer-Anweisungen hat, werden sie nach dem Last-in-First-out-Prinzip ausgeführt. Dies ist oft sehr wichtig, um komplexe Aufräumlogik zu verstehen. Das folgende Beispiel zeigt die Ausführungsreihenfolge von mehreren defer-Anweisungen:

func mehrereDefers() {
    defer fmt.Println("Erste defer-Anweisung")
    defer fmt.Println("Zweite defer-Anweisung")
    defer fmt.Println("Dritte defer-Anweisung")

    fmt.Println("Funktionskörper")
}

func main() {
    mehrereDefers()
}

Die Ausgabe dieses Codes wird sein:

Funktionskörper
Dritte defer-Anweisung
Zweite defer-Anweisung
Erste defer-Anweisung

Da defer dem Last-in-First-out-Prinzip folgt, auch wenn "Erste defer-Anweisung" die zuerst ausstehende ist, wird sie zuletzt ausgeführt.

3 Anwendungen von defer in verschiedenen Szenarien

3.1 Ressourcenfreigabe

In der Go-Sprache wird die defer-Anweisung häufig zur Behandlung der Ressourcenfreigabelogik verwendet, wie z. B. bei Dateioperationen und Datenbankverbindungen. defer stellt sicher, dass nach der Funktionsausführung die entsprechenden Ressourcen unabhängig vom Grund des Verlassens der Funktion ordnungsgemäß freigegeben werden.

Beispiel für Dateioperationen:

func DateiLesen(dateiname string) {
    datei, err := os.Open(dateiname)
    if err != nil {
        log.Fatal(err)
    }
    // Verwende defer, um sicherzustellen, dass die Datei geschlossen wird
    defer datei.Close()

    // Datei-Leseoperationen durchführen...
}

In diesem Beispiel stellt defer datei.Close() sicher, dass die Datei ordnungsgemäß geschlossen und der Datei-Handle-Ressource freigegeben wird, wenn die Funktion endet, nachdem os.Open die Datei erfolgreich geöffnet hat.

Beispiel für Datenbankverbindung:

func DatenbankAbfrage(abfrage string) {
    db, err := sql.Open("mysql", "benutzer:passwort@/datenbankname")
    if err != nil {
        log.Fatal(err)
    }
    // Stelle sicher, dass die Datenbankverbindung mithilfe von defer geschlossen wird
    defer db.Close()

    // Datenbankabfrageoperationen durchführen...
}

Ähnlich stellt defer db.Close() sicher, dass die Datenbankverbindung beim Verlassen der Funktion DatenbankAbfrage ordnungsgemäß geschlossen wird, unabhängig vom Grund (normale Rückkehr oder ausgelöste Ausnahme).

3.2 Sperroperationen in nebenläufiger Programmierung

In der nebenläufigen Programmierung ist es eine bewährte Praxis, defer zur Behandlung der Freigabe von Mutex-Sperren zu verwenden. Dies stellt sicher, dass die Sperre nach der Ausführung des kritischen Bereichs korrekt freigegeben wird und somit Deadlocks vermieden werden.

Beispiel für Mutex-Sperre:

var mutex sync.Mutex

func updateSharedResource() {
    mutex.Lock()
    // Verwende defer, um sicherzustellen, dass die Sperre freigegeben wird
    defer mutex.Unlock()

    // Änderungen am gemeinsam genutzten Ressourcen durchführen...
}

Unabhängig davon, ob die Änderung der gemeinsam genutzten Ressource erfolgreich ist oder ob es zu einem Panik kommt, stellt defer sicher, dass Unlock() aufgerufen wird und anderen Goroutinen ermöglicht, die Sperre zu erhalten.

Tipp: Detaillierte Erklärungen zu Mutex-Sperren werden in den folgenden Kapiteln behandelt. Es reicht jedoch aus, die Anwendungsszenarien von defer zu verstehen.

3 Häufige Fallstricke und Überlegungen für defer

Beim Verwenden von defer werden zwar die Lesbarkeit und die Wartbarkeit des Codes erheblich verbessert, es gibt jedoch auch einige Fallstricke und Überlegungen, die zu beachten sind.

3.1 Sofortige Auswertung von Funktionsparametern in defer

func printValue(v int) {
    fmt.Println("Wert:", v)
}

func main() {
    value := 1
    defer printValue(value)
    // Die Änderung des Werts von `value` wirkt sich nicht auf den bereits an defer übergebenen Parameter aus
    value = 2
}
// Die Ausgabe wird "Wert: 1" sein

Trotz der Änderung des Werts von value nach der defer-Anweisung wird der an printValue in defer übergebene Parameter bereits ausgewertet und festgelegt, daher wird die Ausgabe immer noch "Wert: 1" sein.

3.2 Vorsicht bei der Verwendung von defer in Schleifen

Die Verwendung von defer innerhalb einer Schleife kann dazu führen, dass Ressourcen nicht freigegeben werden, bevor die Schleife endet, was zu Ressourcenlecks oder Erschöpfung führen kann.

3.3 Vermeiden von "Freigabe nach Verwendung" in der parallelen Programmierung

In parallelen Programmen ist es wichtig sicherzustellen, dass alle Goroutinen nicht versuchen, auf die Ressource zuzugreifen, nachdem sie freigegeben wurde, um Wettlaufbedingungen zu vermeiden.

4. Beachten Sie die Ausführungsreihenfolge von defer-Anweisungen

defer-Anweisungen folgen dem Last-In-First-Out (LIFO)-Prinzip, wobei die zuletzt deklarierte defer-Anweisung zuerst ausgeführt wird.

Lösungen und bewährte Praktiken:

• Beachte immer, dass Funktionsparameter in defer-Anweisungen zum Zeitpunkt der Deklaration ausgewertet werden.
• Wenn defer in einer Schleife verwendet wird, kann die Verwendung anonymer Funktionen oder das explizite Aufrufen der Ressourcenfreigabe in Betracht gezogen werden.
• In einer parallelen Umgebung sicherstellen, dass alle Goroutinen ihre Operationen abgeschlossen haben, bevor defer zur Freigabe von Ressourcen verwendet wird.
• Beim Schreiben von Funktionen mit mehreren defer-Anweisungen die Ausführungsreihenfolge und Logik sorgfältig berücksichtigen.

Durch die Beachtung dieser bewährten Praktiken können die meisten Probleme beim Verwenden von defer vermieden und zu einer robusteren und wartungsfreundlicheren Go-Code führen.