Dies ist Teil 1 unserer Serie ?Mastering Go Concurrency“, in der wir Folgendes behandeln:

• Wie Goroutinen funktionieren und ihr Lebenszyklus
• Kanalkommunikation zwischen Goroutinen
• Gepufferte Kan?le und ihre Anwendungsf?lle
• Praxisbeispiele und Visualisierungen

Wir beginnen mit den Grundlagen und entwickeln schrittweise ein Gespür dafür, wie wir diese effektiv nutzen k?nnen.

Es wird etwas lang, eher sehr lang, also macht euch bereit.

Wir stehen Ihnen w?hrend des gesamten Prozesses zur Seite.

Grundlagen von Goroutinen

Beginnen wir mit einem einfachen Programm, das mehrere Dateien herunterl?dt.

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now()

    downloadFile("file1.txt")
    downloadFile("file2.txt")
    downloadFile("file3.txt")

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

Das Programm dauert insgesamt 6 Sekunden, da jeder 2-sekündige Download abgeschlossen sein muss, bevor der n?chste beginnt. Stellen wir uns das vor:

Wir k?nnen diese Zeit verkürzen, indem wir unser Programm so ?ndern, dass es Go-Routinen verwendet:

Hinweis: Schlüsselwort vor Funktionsaufruf eingeben

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    // Launch downloads concurrently
    go downloadFile("file1.txt")
    go downloadFile("file2.txt")
    go downloadFile("file3.txt")

    fmt.Println("All downloads completed!")
}

Warte was? wurde nichts gedruckt? Warum?

Lassen Sie uns dies visualisieren, um zu verstehen, was passieren k?nnte.

Aus der obigen Visualisierung gehen wir hervor, dass die Hauptfunktion existiert, bevor die Goroutinen fertig sind. Eine Beobachtung ist, dass der gesamte Lebenszyklus einer Goroutine von der Hauptfunktion abh?ngt.

Hinweis: Die Hauptfunktion an sich ist eine Goroutine ;)

Um dies zu beheben, müssen wir die Haupt-Goroutine warten lassen, bis die anderen Goroutinen abgeschlossen sind. Dafür gibt es mehrere M?glichkeiten:

1. Warten Sie ein paar Sekunden (knifflige Art)
2. WaitGroup verwenden (richtige Vorgehensweise, als n?chstes)
3. Verwendung von Kan?len (wir werden weiter unten darauf eingehen)

Lassen Sie uns einige Sekunden warten, bis die Go-Routinen abgeschlossen sind.

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now()

    downloadFile("file1.txt")
    downloadFile("file2.txt")
    downloadFile("file3.txt")

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

Das Problem dabei ist, dass wir m?glicherweise nicht wissen, wie viel Zeit eine Goroutine dauern k?nnte. In diesem Fall haben wir jeweils eine konstante Zeit, aber in realen Szenarien sind wir uns bewusst, dass die Downloadzeit variiert.

Kommt die sync.WaitGroup

Eine sync.WaitGroup in Go ist ein Parallelit?tskontrollmechanismus, der verwendet wird, um darauf zu warten, dass die Ausführung einer Sammlung von Goroutinen abgeschlossen ist.

Hier sehen wir uns das in Aktion an und visualisieren es:

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    // Launch downloads concurrently
    go downloadFile("file1.txt")
    go downloadFile("file2.txt")
    go downloadFile("file3.txt")

    fmt.Println("All downloads completed!")
}

Lassen Sie uns dies visualisieren und die Funktionsweise von sync.WaitGroup verstehen:

Gegenmechanismus:

• WaitGroup unterh?lt einen internen Z?hler
• wg.Add(n) erh?ht den Z?hler um n
• wg.Done() dekrementiert den Z?hler um 1
• wg.Wait() blockiert, bis der Z?hler 0 erreicht

Synchronisierungsablauf:

• Haupt-Goroutine ruft Add(3) auf, bevor Goroutinen gestartet werden
• Jede Goroutine ruft Done() auf, wenn sie abgeschlossen ist
• Die Hauptgoroutine wird bei Wait() blockiert, bis der Z?hler 0 erreicht
• Wenn der Z?hler 0 erreicht, wird das Programm fortgesetzt und sauber beendet

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now() // Record start time

    go downloadFile("file1.txt")
    go downloadFile("file2.txt")
    go downloadFile("file3.txt")

    // Wait for goroutines to finish
    time.Sleep(3 * time.Second)

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

Kan?le

So haben wir ein gutes Verst?ndnis dafür bekommen, wie die Goroutinen funktionieren. Nein, wie kommunizieren zwei Go-Routinen? Hier kommt der Kanal ins Spiel.

Kan?le in Go sind ein leistungsstarkes Nebenl?ufigkeitsprimitiv, das für die Kommunikation zwischen Goroutinen verwendet wird. Sie bieten Goroutinen die M?glichkeit, Daten sicher auszutauschen.

Stellen Sie sich Kan?le als Pipes vor: Eine Goroutine kann Daten an einen Kanal senden und eine andere kann sie empfangen.

hier sind einige Eigenschaften:

1. Kan?le blockieren von Natur aus.
2. Eine An Kanal senden Operation ch <- value blockiert, bis eine andere Goroutine vom Kanal empf?ngt.
3. Eine Vom Kanal empfangen-Operation <-ch blockiert, bis eine andere Goroutine an den Kanal sendet.

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now()

    downloadFile("file1.txt")
    downloadFile("file2.txt")
    downloadFile("file3.txt")

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

Warum führt ch <- ?hello“ zu einem Deadlock? Da Kan?le von Natur aus blockieren und wir hier ?Hallo“ weitergeben, wird die Haupt-Goroutine blockiert, bis es einen Empf?nger gibt, und da es keinen Empf?nger gibt, bleibt sie h?ngen.

Beheben wir dieses Problem, indem wir eine Goroutine hinzufügen

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    // Launch downloads concurrently
    go downloadFile("file1.txt")
    go downloadFile("file2.txt")
    go downloadFile("file3.txt")

    fmt.Println("All downloads completed!")
}

Lass uns das visualisieren:

Diesmal wird die Nachricht von einer anderen Goroutine gesendet, damit die Haupt-Goroutine nicht blockiert wird, w?hrend sie an den Kanal gesendet wird, sodass sie zu msg := <-ch verschoben wird, wo sie die Haupt-Goroutine blockiert, bis sie die empf?ngt Nachricht.

Behebung des Hauptproblems, bei der Verwendung des Kanals nicht auf andere zu warten

Jetzt verwenden wir den Kanal, um das Problem mit dem Datei-Downloader zu beheben (main wartet nicht, bis andere fertig sind).

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now() // Record start time

    go downloadFile("file1.txt")
    go downloadFile("file2.txt")
    go downloadFile("file3.txt")

    // Wait for goroutines to finish
    time.Sleep(3 * time.Second)

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

Visualisierung:

Machen wir einen Probelauf, um es besser zu verstehen:

Programmstart:

Hauptgoroutine erstellt Fertigkanal
Startet drei Download-Goroutinen
Jede Goroutine erh?lt einen Verweis auf denselben Kanal

Ausführung herunterladen:

1. Alle drei Downloads laufen gleichzeitig
2. Jeder dauert 2 Sekunden
3. Sie k?nnen in beliebiger Reihenfolge enden

Kanalschleife:

1. Hauptgoroutine tritt in die Schleife ein: for i := 0; ich < 3; ich
2. Jedes <-done blockiert, bis ein Wert empfangen wird
3. Die Schleife stellt sicher, dass wir auf alle drei Abschlusssignale warten

Schleifenverhalten:

1. Iteration 1: Blockiert, bis der erste Download abgeschlossen ist
2. Iteration 2: Blockiert, bis der zweite Download abgeschlossen ist
3. Iteration 3: Blockiert, bis der endgültige Download abgeschlossen ist

Die Reihenfolge der Fertigstellung spielt keine Rolle!

Beobachtungen:
? Jeder Versand (erledigt <- true) hat genau einen Empfang (<-erledigt)
? Die Hauptgoroutine koordiniert alles durch die Schleife

Wie k?nnen zwei Goroutinen kommunizieren?

Wir haben bereits gesehen, wie zwei Goroutinen kommunizieren k?nnen. Wann? Die ganze Zeit. Vergessen wir nicht, dass die Hauptfunktion auch eine Goroutine ist.

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now()

    downloadFile("file1.txt")
    downloadFile("file2.txt")
    downloadFile("file3.txt")

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

Lassen Sie uns dies visualisieren und einen Probelauf durchführen:

Gepufferte Kan?le

Warum brauchen wir gepufferte Kan?le?
Ungepufferte Kan?le blockieren sowohl den Sender als auch den Empf?nger, bis die andere Seite bereit ist. Wenn Hochfrequenzkommunikation erforderlich ist, k?nnen ungepufferte Kan?le zu einem Engpass werden, da beide Goroutinen pausieren müssen, um Daten auszutauschen.

Eigenschaften gepufferter Kan?le:

1. FIFO (First In, First Out, ?hnlich der Warteschlange)
2. Feste Gr??e, bei der Erstellung festgelegt
3. Blockiert den Absender, wenn der Puffer voll ist
4. Blockiert den Empf?nger, wenn der Puffer leer ist

Wir sehen es in Aktion:

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now()

    downloadFile("file1.txt")
    downloadFile("file2.txt")
    downloadFile("file3.txt")

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

Ausgabe (vor dem Auskommentieren des ch<-"dritten")

Warum hat es die Haupt-Goroutine nicht blockiert?

1. Ein gepufferter Kanal erm?glicht das Senden bis zu seiner Kapazit?t, ohneden Absender zu blockieren.

2. Der Kanal hat eine Kapazit?t von 2, was bedeutet, dass er zwei Werte in seinem Puffer speichern kann, bevor er blockiert wird.

3. Der Puffer ist bereits mit ?erster“ und ?zweiter“ voll. Da es keinen gleichzeitigen Empf?nger gibt, der diese Werte konsumiert, wird der Sendevorgang auf unbestimmte Zeit blockiert.

4. Da die Haupt-Goroutine auch für das Senden verantwortlich ist und es keine anderen aktiven Goroutinen gibt, die Werte vom Kanal empfangen, ger?t das Programm beim Versuch, die dritte Nachricht zu senden, in einen Deadlock.

Das Auskommentieren der dritten Nachricht führt zu einem Deadlock, da die Kapazit?t jetzt voll ist und die dritte Nachricht blockiert wird, bis der Puffer frei wird.

Wann sollten gepufferte Kan?le im Vergleich zu ungepufferten Kan?len verwendet werden?

Wichtige Erkenntnisse

Verwenden Sie gepufferte Kan?le, wenn:

1. Sie müssen das Timing von Sender und Empf?nger entkoppeln.
2. Die Leistung kann durch das Stapeln oder Einreihen von Nachrichten in die Warteschlange verbessert werden.
3. Die Anwendung kann Verz?gerungen bei der Verarbeitung von Nachrichten tolerieren, wenn der Puffer voll ist.

Verwenden Sie ungepufferte Kan?le, wenn:

1. Die Synchronisierung zwischen Goroutinen ist von entscheidender Bedeutung.
2. Sie m?chten Einfachheit und eine sofortige übergabe von Daten.
3. Die Interaktion zwischen Sender und Empf?nger muss sofort erfolgen.

Diese Grundlagen schaffen die Grundlage für fortgeschrittenere Konzepte. In unseren kommenden Beitr?gen werden wir Folgendes untersuchen:

N?chster Beitrag:

1. Parallelit?tsmuster
2. Mutex und Speichersynchronisation

Bleiben Sie dran, w?hrend wir unser Verst?ndnis der leistungsstarken Parallelit?tsfunktionen von Go weiter ausbauen!

Das obige ist der detaillierte Inhalt vonGoroutinen und Kan?le in Golang mit intuitiven Bildern verstehen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!