Warum gibt das Go-Programm die Summe der Berechnung vor der Nachricht im angegebenen Codeausschnitt aus, obwohl die Haupt-Goroutine blockiert, bis ein Signal vom Kanal empfangen wird?

Go-Parallelität und Kanalverwirrung

In Go ermöglicht die Parallelität die gleichzeitige Ausführung mehrerer Aufgaben mithilfe von Goroutinen. Kanäle erleichtern die Kommunikation zwischen diesen Goroutinen. Das Verständnis der Parallelität kann jedoch eine Herausforderung sein, insbesondere beim Umgang mit Kanälen.

Bedenken Sie den folgenden Codeausschnitt:

<code class="go">package main

import "fmt"

func display(msg string, c chan bool) {
    fmt.Println("display first message:", msg)
    c <- true
}

func sum(c chan bool) {
    sum := 0
    for i := 0; i < 10000000000; i++ {
        sum++
    }
    fmt.Println(sum)
    c <- true
}

func main() {
    c := make(chan bool)

    go display("hello", c)
    go sum(c)
    <-c
}</code>

In diesem Code erstellen wir zwei Goroutinen: display und sum. Die Anzeige-Goroutine gibt eine Nachricht aus, sendet ein Signal an den Kanal und wartet dann auf eine Antwort. Die Summengoroutine führt eine lange Berechnung durch, gibt das Ergebnis aus und sendet außerdem ein Signal an den Kanal. In der Haupt-Goroutine blockieren wir, bis ein Signal vom Kanal empfangen wird.

Die erwartete Ausgabe des Codes ist:

display first message: hello

Wir beobachten jedoch, dass das Programm beide Nachrichten ausgibt und die Summe der Berechnung:

display first message: hello
10000000000

Verstehen des Problems

Das Problem entsteht aufgrund der nichtdeterministischen Natur der Goroutine-Planung. Der Scheduler in Go wählt frei zwischen den Goroutinen, die nicht blockiert sind. In diesem Beispiel kann der Scheduler jede der Goroutinen zu einem bestimmten Zeitpunkt ausführen.

Eine mögliche Ausführungsreihenfolge ist:

1. main erstellt die Goroutinen.
2. Die Der Scheduler wählt die Anzeige aus, die die Nachricht druckt und auf eine Antwort wartet.
3. Der Scheduler wechselt zur Summe, die lange ausgeführt wird.
4. Der Scheduler wechselt zurück zur Anzeige, die das Signal sendet .
5. Der Planer wechselt in den Hauptmodus, der das Signal druckt und beendet.

In diesem Szenario wird die Summe gedruckt, bevor das Display das Signal sendet, was zu der unerwarteten Ausgabe führt.

Lösung

Um sicherzustellen, dass das Programm nur die Nachricht druckt und beendet, bevor die Summe berechnet wird, können wir einen anderen Ansatz verwenden:

<code class="go">func main() {
    result := make(chan string)

    go display("hello", result)
    go sum(result)

    fmt.Println(<-result)
}</code>

In dieser überarbeiteten Version trägt der Ergebniskanal einen einzelnen Wert, die Nachricht von der Anzeige-Goroutine. Die Haupt-Goroutine gibt nun den Wert aus dem Kanal aus und stellt so sicher, dass sie die Nachricht empfängt, bevor sie beendet wird.

Das obige ist der detaillierte Inhalt vonWarum gibt das Go-Programm die Summe der Berechnung vor der Nachricht im angegebenen Codeausschnitt aus, obwohl die Haupt-Goroutine blockiert, bis ein Signal vom Kanal empfangen wird?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!