Warum gibt das folgende Go-Programm einen Deadlock-Fehler aus: „Schwerwiegender Fehler: Alle Goroutinen schlafen – Deadlock!“

In der Go-Sprache ist Deadlock ein häufiger Fehler. Wenn alle Goroutinen schlafen, tritt ein schwerwiegender Fehler auf: „Schwerwiegender Fehler: Alle Goroutinen schlafen – Deadlock!“. Diese Situation tritt normalerweise auf, wenn mehrere Goroutinen aufeinander warten. Wenn eine Goroutine darauf wartet, dass eine andere Goroutine einen Vorgang abschließt, und eine andere Goroutine darauf wartet, dass die erste Goroutine einen Vorgang abschließt, kommt es zu einem Deadlock. In diesem Fall kann das Programm nicht weiter ausgeführt werden, da nicht alle Goroutinen weiter ausgeführt werden können. Um Deadlock-Fehler zu vermeiden, müssen wir die Abhängigkeiten zwischen Goroutinen sorgfältig entwerfen und verwalten, um sicherzustellen, dass sie ordnungsgemäß zusammenarbeiten können.

Frageninhalt

Ich bin neu bei Golang und versuche, einige typische Produzenten-Konsumenten von Kanälen zu verwenden. Ich verstehe, dass sowohl Produzent als auch Verbraucher über denselben Kanal schreiben und lesen sollten. Aber nur zum Experimentieren habe ich sie dazu gebracht, über verschiedene Kanäle zu schreiben und zu lesen, wie unten gezeigt

package main
    
    import (
        "fmt"
        "sync"
    )
    
    func main() {
    
        var wg sync.WaitGroup
        wg.Add(2)
    
        fmt.Println("Starting the main application")
    
        channel :=make( chan int)
        channel1 :=make( chan int)
    
    
        go generateNumbersV2(&wg, channel)
        go printNumbersV2(&wg, channel1)
    
    
        fmt.Println("Waiting for other goroutines")
        wg.Wait()
        //close()
        //close(channel)
    
        fmt.Println("All goroutines finished")
    }
    
    func printNumbersV2(wg *sync.WaitGroup, rc <-chan int) {
        defer wg.Done()
    
        for idx:=0 ;idx<3;idx++ {
    
            val := <-rc
            fmt.Println("******value received from channel ",val)
        }
    }
    
    func generateNumbersV2(wg *sync.WaitGroup, wc chan<- int) {
        defer wg.Done()
    
        for idx:=0 ;idx<3;idx++ {
    
             wc<-idx
            fmt.Println("###value written to channel ",idx)
        }
    
    }

Wenn ich das Programm ausführe, erhalte ich die folgende Fehlermeldung.

fatal error: all goroutines are asleep - deadlock!

Ich weiß zwar, dass beide Goroutinen blockiert sind, eine beim Leseaufruf an Kanal 1 und die andere beim Schreibaufruf an Kanal, sodass das Programm nie beendet wird. Aber meine Frage ist: Wenn das Programm tatsächlich auf einen Wert in diesen Kanälen wartet, sollte das Programm dann nicht auf unbestimmte Zeit warten, anstatt es als Deadlock zu deklarieren? Was passiert, wenn später aufgrund einiger Lese-/Schreibvorgänge im Netzwerk die Werte eintreffen und eine andere Go-Routine in diese Kanäle schreibt?

Workaround

Ein laufendes Programm wird nur dann mit einer Deadlock-Panik beendet, wenn alle Goroutinen auf Synchronisierungsprimitiven blockiert sind. Wenn alle Goroutinen blockiert sind und auf Kanaloperationen und/oder Mutex-Sperren warten, ist ein Netzwerkempfang nicht möglich, da keine Goroutine auf Netzwerkverbindungen lauscht. Dies bedeutet auch, dass es in einem Programm mit vielen Goroutinen möglicherweise viele Gruppen blockierter Goroutinen gibt, das Programm jedoch weiterhin ausgeführt wird, da es andere Goroutinen gibt, die weiterhin ausgeführt werden können.

Das obige ist der detaillierte Inhalt vonWarum gibt das folgende Go-Programm einen Deadlock-Fehler aus: „Schwerwiegender Fehler: Alle Goroutinen schlafen – Deadlock!“. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!