Wie kann man elegant auf den Abschluss von Go-Routinen warten?

So warten Sie elegant auf den Abschluss von Go-Routinen

In Go wird Parallelität durch Goroutinen erreicht, bei denen es sich um leichtgewichtige Threads handelt, die gleichzeitig ausgeführt werden die Hauptroutine. Um sicherzustellen, dass das Programm nicht beendet wird, bevor alle Goroutinen ihre Aufgaben abgeschlossen haben, ist es wichtig, ordnungsgemäß auf deren Abschluss zu warten.

Verwenden eines Kanals, um den Abschluss zu signalisieren

Ein gängiger Ansatz zum Warten auf Goroutinen ist die Verwendung eines booleschen Kanals. Wenn eine Goroutine ihre Aufgabe abschließt, sendet sie einen wahren Wert an den Kanal und die Hauptroutine wartet auf diesen Wert, indem sie vom Kanal empfängt.

func do_stuff(done chan bool) {
    fmt.Println("Doing stuff")
    done <- true
}

func main() {
    fmt.Println("Main")
    done := make(chan bool)
    go do_stuff(done)
    <-done
}

Warum funktioniert <-done?

<-done ist ein blockierender Empfangsvorgang. Das bedeutet, dass die Hauptroutine wartet, bis ein Wert an den Fertig-Kanal gesendet wird. Da die Goroutine „do_stuff“ nach Abschluss explizit einen wahren Wert an den Kanal sendet, empfängt ihn die Hauptroutine und setzt die Ausführung fort.

Was passiert, wenn wir die letzte Zeile auskommentieren?

Wenn wir die letzte Zeile auskommentieren, erhalten wir einen Deadlock-Fehler, weil der Kanal leer ist und keine andere Goroutine Werte an ihn sendet. Daher wartet die Hauptroutine unendlich lange auf den Empfang eines Werts, was zu einem Deadlock führt.

Alternativer Ansatz mithilfe des Synchronisierungspakets

Für komplexere Parallelitätsszenarien ist die Synchronisierung erforderlich Das Paket bietet praktische Synchronisierungsmechanismen. Wenn Sie beispielsweise eine Reihe lang laufender Funktionen parallelisieren müssen, zeigt das folgende Codefragment, wie Sie den Typ sync.WaitGroup verwenden:

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            longOp()
            wg.Done()
        }()
    }

    // will wait until wg.Done is called 10 times
    // since we made wg.Add(1) call 10 times
    wg.Wait()
}

func longOp() {
    time.Sleep(time.Second * 2)
    fmt.Println("long op done")
}

In diesem Beispiel stellt die WaitGroup sicher, dass die Hauptroutine wird erst beendet, wenn alle Goroutinen wg.Done aufgerufen haben.

Das obige ist der detaillierte Inhalt vonWie kann man elegant auf den Abschluss von Go-Routinen warten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!