Warum führt die Übergabe einer WaitGroup als Wert in Go zu einem Deadlock und wie kann dieser behoben werden?

Deadlock bei Go-Kanälen: Ein Problem unterschiedlicher Tragweite

In einem Golang-Programm erleichtern Kanäle die Kommunikation zwischen Goroutinen. Der Missbrauch von Kanälen kann jedoch zu Deadlocks führen, wie im folgenden Code gezeigt:

<br>package main</p>
<p>import (</p>
<pre class="brush:php;toolbar:false">"fmt"
"sync"

)

func push(c chan int, wg sync.WaitGroup) {

for i := 0; i < 5; i++ {
    c <- i
}
wg.Done()

}

func pull(c chan int, wg sync.WaitGroup) {

for i := 0; i < 5; i++ {
    result, ok := <-c
    fmt.Println(result, ok)
}
wg.Done()

}

func main() {

var wg sync.WaitGroup
wg.Add(2)
c := make(chan int)

go push(c, wg)
go pull(c, wg)

wg.Wait() // Block the main thread until goroutines complete

}

Beim Ausführen dieses Programms kann Folgendes auftreten der folgende Fehler:

fatal error: all goroutines are asleep - deadlock!

Um zu verstehen, warum dieser Deadlock auftritt, schauen wir uns den Code an:

• main erstellt eine WaitGroup, einen Kanal c und Goroutinen für Push und Pull Operationen.
• Die Push- und Pull-Funktionen verwenden die WaitGroup, um ihre Ausführung zu synchronisieren.
• Die Push-Funktion sendet Werte in einer Schleife an c und signalisiert deren Abschluss durch Aufrufen von wg.Done().
• Die Pull-Funktion empfängt Werte von c und gibt sie aus. Es signalisiert auch den Abschluss mit wg.Done().

Das Problem liegt darin, wie die WaitGroup an die Goroutinen übergeben wird. Wenn ein Wert ohne kaufmännisches Und (&) übergeben wird, wird er als Wert und nicht als Referenz übergeben. In diesem Fall wird für jede Goroutine eine Kopie der WaitGroup erstellt.

Wenn daher jede Goroutine wg.Done() aufruft, ändert sie ihre lokale Kopie der WaitGroup. Da der Hauptthread wartet, bis wg angibt, dass alle Goroutinen abgeschlossen sind, wartet er auf unbestimmte Zeit, da keine der Goroutinen die ursprüngliche WaitGroup aktualisiert. Dies führt zu einem Deadlock.

Um dieses Problem zu beheben, müssen wir die WaitGroup als Referenz übergeben. Dadurch wird sichergestellt, dass beide Goroutinen dieselbe Instanz der WaitGroup ändern und ihre Fertigstellung dem Hauptthread korrekt signalisieren.

Hier ist eine überarbeitete Version des Codes mit der Korrektur:

<br>Pakethauptseite</p>
<p>import (</p>
<pre class="brush:php;toolbar:false">"fmt"
"sync"

)

func push(c chan int, wg *sync.WaitGroup) {

for i := 0; i < 5; i++ {
    c <- i
}
wg.Done()

}

func pull(c chan int, wg *sync.WaitGroup) {

for i := 0; i < 5; i++ {
    result, ok := <-c
    fmt.Println(result, ok)
}
wg.Done()

}

func main() {

var wg sync.WaitGroup
wg.Add(2)
c := make(chan int)

go push(c, &wg) // Pass the WaitGroup by reference using the ampersand
go pull(c, &wg) // Pass the WaitGroup by reference using the ampersand

wg.Wait()

}

Durch die Übergabe der WaitGroup als Referenz stellen wir sicher, dass der Hauptthread korrekt bestimmen kann, wann beide Goroutinen ihre Aufgaben abgeschlossen haben, und vermeiden so den Deadlock.

Das obige ist der detaillierte Inhalt vonWarum führt die Übergabe einer WaitGroup als Wert in Go zu einem Deadlock und wie kann dieser behoben werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!