Parallelitätskontrolle in Golang und Go WaitGroup

Parallelitätskontrolle und Go WaitGroup in Golang

In Golang können wir Goroutine verwenden, um gleichzeitige Ausführungsaufgaben zu implementieren. In einigen Fällen müssen wir jedoch die Anzahl gleichzeitiger Ausführungen kontrollieren, um einen übermäßigen Ressourcenverbrauch oder Probleme mit Parallelitätskonflikten zu vermeiden. Golang bietet einige Methoden zur Erzielung einer Parallelitätskontrolle. Die am häufigsten verwendete Methode ist die Verwendung von Go WaitGroup.

Go WaitGroup ist ein Zählsemaphor, mit dem darauf gewartet wird, dass eine Gruppe von Goroutinen die Ausführung abschließt. Wenn wir eine Gruppe von Goroutinen starten, können wir WaitGroup verwenden, um den Status dieser Goroutinen zu verfolgen und den nächsten Schritt auszuführen, nachdem alle Goroutinen abgeschlossen sind.

Nachfolgend verwenden wir ein konkretes Codebeispiel, um die Parallelitätskontrolle in Golang und die Verwendung von Go WaitGroup zu demonstrieren.

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    numWorkers := 5
    var wg sync.WaitGroup

    for i := 0; i < numWorkers; i++ {
        wg.Add(1) // 每启动一个goroutine，等待组加1
        go worker(i, &wg)
    }

    wg.Wait() // 等待所有goroutine完成

    fmt.Println("All workers have finished")
}

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // goroutine执行完毕，等待组减1
    
    fmt.Printf("Worker %d started
", id)
    time.Sleep(time.Second) // 模拟耗时操作
    fmt.Printf("Worker %d finished
", id)
}

In diesem Beispiel haben wir 5 Goroutinen und die Aufgabe jeder Ausführung besteht darin, die Worker-Funktion aufzurufen. Zuerst haben wir eine WaitGroup-Variable wg definiert und 5 Goroutinen in der Hauptfunktion gestartet. Jede Goroutine ruft die Worker-Funktion auf und betreibt die WaitGroup, indem sie einen Zeiger an wg übergibt.

In der Worker-Funktion verwenden wir defer wg.Done(), um die Anzahl der wartenden Gruppen zu reduzieren, nachdem die Goroutine die Ausführung abgeschlossen hat. Das bedeutet, dass jede Goroutine die Funktion Done() aufruft, um die WaitGroup zu benachrichtigen, wenn sie abgeschlossen ist. Anschließend haben wir jeder Worker-Funktion einige simulierte zeitaufwändige Vorgänge hinzugefügt, um die Auswirkungen der gleichzeitigen Ausführung zu beobachten.

In der Hauptfunktion rufen wir wg.Wait() auf, um auf den Abschluss aller Goroutinen zu warten. Dies führt dazu, dass die Hauptfunktion blockiert wird, nachdem die Ausführung aller Goroutinen abgeschlossen ist, bis der WaitGroup-Zähler Null erreicht.

Führen Sie den obigen Code aus. Sie erhalten eine Ausgabe ähnlich der folgenden:

Worker 0 started
Worker 1 started
Worker 2 started
Worker 3 started
Worker 4 started
Worker 3 finished
Worker 2 finished
Worker 0 finished
Worker 1 finished
Worker 4 finished
All workers have finished

Wie aus der Ausgabe ersichtlich ist, starten und laufen alle Goroutinen gleichzeitig und benachrichtigen die Hauptfunktion nach Abschluss.

Durch die Verwendung von Go WaitGroup können wir die Anzahl gleichzeitiger Ausführungen einfach steuern und nachfolgende Vorgänge ausführen, nachdem alle Goroutinen abgeschlossen sind. Dies ist sehr hilfreich, um umfangreiche gleichzeitige Aufgaben zu bewältigen oder den Ressourcenverbrauch zu begrenzen.

Zusammenfassend lässt sich sagen, dass Parallelitätskontrolle und Go WaitGroup in Golang wichtige Werkzeuge für die Implementierung gleichzeitiger Programmierung sind. Mit WaitGroup können wir die Ausführung einer Gruppe von Goroutinen verfolgen und steuern, um die Korrektheit und Stabilität gleichzeitiger Vorgänge sicherzustellen. Auf diese Weise können wir Multi-Core-Prozessoren und -Ressourcen besser nutzen und die Effizienz der Programmausführung verbessern.

Das obige ist der detaillierte Inhalt vonParallelitätskontrolle in Golang und Go WaitGroup. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!