Warum führt der bereitgestellte Go-Code mit WaitGroup und gepuffertem Kanal zu einem Deadlock?

Deadlocks in Go mit WaitGroup und Buffered Channels

In Go kommt es zu einem Deadlock, wenn mehrere Goroutinen darauf warten, dass der andere abgeschlossen wird in einer Pattsituation. Diese Situation kann auftreten, wenn gepufferte Kanäle und WaitGroups falsch verwendet werden.

Beachten Sie den folgenden Code:

<code class="go">package main

import "fmt"
import "sync"

func main() {
    ch := make(chan []int, 4)
    var m []int

    var wg sync.WaitGroup
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            ch <- m
            return
        }()
    }
    wg.Wait()

    for c := range ch {
        fmt.Printf("c is %v", c)
    }
}</code>

Dieser Code soll einen Kanal mit einer Puffergröße von 4 erstellen und 5 Goroutinen starten , wobei jeder ein leeres Slice an den Kanal sendet. Die Haupt-Goroutine wartet auf den Abschluss aller Goroutinen und bewegt sich dann über den Kanal.

Dieser Code führt jedoch zu einem Deadlock. Warum?

Ursache des Deadlocks:

Es gibt zwei Probleme im Code:

1. Kanalkapazität: Der Kanal hat eine Kapazität von 4, was bedeutet, dass es bis zu 4 Elemente aufnehmen kann. Es gibt jedoch 5 Goroutinen, die versuchen, an den Kanal zu senden, was zu einer Situation führt, in der die letzte Goroutine blockiert und darauf wartet, dass ein Slot freigegeben wird.
2. Schließen des Kanals: Die Range-Ch-Schleife wartet weiterhin auf Elemente um den Kanal zu betreten. Da keine Goroutinen mehr zum Schreiben in den Kanal vorhanden sind, wird die Schleife auf unbestimmte Zeit warten.

Lösungen:

1. Kanalkapazität erhöhen: Durch die Erhöhung der Kanalkapazität auf 5 stehen genügend Slots zur Verfügung, damit alle Goroutinen ihre Werte ohne Blockierung senden können. Darüber hinaus signalisiert das Schließen des Kanals, nachdem die Goroutinen mit dem Schreiben fertig sind, der Bereichsschleife, dass keine weiteren Elemente kommen, wodurch verhindert wird, dass sie auf unbestimmte Zeit wartet.

   <code class="go">ch := make(chan []int, 5)
   ...
   wg.Wait()
   close(ch)</code>

2. Verwendung abgeschlossen () innerhalb der Schleife: Anstatt den Kanal zu schließen, kann man die Done()-Methode von WaitGroup verwenden, um zu signalisieren, wann die letzte Goroutine beendet ist. Durch den Aufruf von Done() innerhalb der Bereichsschleife wird die Haupt-Goroutine benachrichtigt, wenn der Kanal leer ist und die Schleife beendet werden kann.

   <code class="go">go func() {
       for c := range ch {
           fmt.Printf("c is %v\n", c)
           wg.Done()
       }
   }()
   wg.Wait()</code>

Diese Lösungen lösen den Deadlock, indem sie dies sicherstellen Der Kanal verfügt über ausreichende Kapazität und die Bereichsschleife wird beendet, wenn keine Elemente mehr aus dem Kanal gelesen werden können.

Das obige ist der detaillierte Inhalt vonWarum führt der bereitgestellte Go-Code mit WaitGroup und gepuffertem Kanal zu einem Deadlock?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!