Effiziente Kombination aus Golang WaitGroup und Coroutine-Pool

Die effiziente Kombination von Golang WaitGroup und Coroutine-Pool erfordert spezifische Codebeispiele

Einführung:
Go-Sprache ist eine Sprache, die die gleichzeitige Programmierung betont und durch Coroutine (Goroutine) eine effiziente gleichzeitige Ausführung erreicht. In einigen Szenarien, in denen mehrere Aufgaben gleichzeitig ausgeführt werden müssen, kann die Kombination aus WaitGroup und Coroutine-Pool die Ausführungseffizienz und Ressourcennutzung des Programms effektiv verbessern. In diesem Artikel wird die Verwendung von WaitGroup und dem Coroutine-Pool in Golang vorgestellt, um eine effiziente gleichzeitige Programmierung zu erreichen, und es werden spezifische Codebeispiele bereitgestellt.

1. Einführung in WaitGroup
WaitGroup ist ein Tool in der Go-Sprache, mit dem auf den Abschluss einer Gruppe von Coroutinen gewartet wird. Sein Quellcode ist wie folgt definiert:

type WaitGroup struct {
    noCopy noCopy

    // 64位的值：高32位存储计数器，低32位存储等待计数器
    // 这个变量可以被原子操作加载和存储。
    // 在64位同步原语中，它必须在64位边界对齐。
    // 是一个强制的要求。
    state1 [3]uint32
}

WaitGroup wird normalerweise in der Haupt-Goroutine erstellt, und dann ruft jede Unter-Goroutine in der Haupt-Goroutine die Add-Methode auf, um den Zähler zu erhöhen, und nach Abschluss der Ausführung wird die Done-Methode aufgerufen wird verwendet, um den Zähler zu dekrementieren. Die Haupt-Goroutine kann über die Wait-Methode darauf warten, dass der Zähler auf Null zurückkehrt. Der spezifische Beispielcode lautet wie folgt:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    wg.Add(3)

    go func() {
        defer wg.Done()
        fmt.Println("Task 1 executing")
    }()

    go func() {
        defer wg.Done()
        fmt.Println("Task 2 executing")
    }()

    go func() {
        defer wg.Done()
        fmt.Println("Task 3 executing")
    }()

    wg.Wait()
    fmt.Println("All tasks completed")
}

Im obigen Beispiel erstellen wir ein WaitGroup-Objekt und erhöhen dann den Zähler, indem wir die Add-Methode aufrufen. Als nächstes haben wir drei Unter-Goroutinen erstellt. Nachdem jede Goroutine ausgeführt wurde, wird der Zähler über die Done-Methode dekrementiert. Schließlich wartet die Haupt-Goroutine darauf, dass der Zähler auf Null zurückkehrt, indem sie die Wait-Methode aufruft. Wenn alle Aufgaben erledigt sind, gibt das Programm „Alle Aufgaben erledigt“ aus.

2. Einführung in den Coroutine-Pool
Bei der gleichzeitigen Programmierung ist der Goroutine-Pool ein häufig verwendeter Modus. Indem Sie eine feste Anzahl von Goroutinen erstellen und Aufgaben gleichmäßig auf diese verteilen, können Sie den Aufwand vermeiden, der durch das ständige Erstellen und Zerstören von Goroutinen entsteht. In der Go-Sprache können Sie Kanäle verwenden, um Coroutine-Pools zu implementieren. Der spezifische Beispielcode lautet wie folgt:

package main

import (
    "fmt"
    "sync"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("Worker", id, "started job", j)
        fib := fibonacci(j)
        fmt.Println("Worker", id, "finished job", j)
        results <- fib
    }
}

func fibonacci(n int) int {
    if n <= 1 {
        return n
    }

    return fibonacci(n-1) + fibonacci(n-2)
}

const numJobs = 5
const numWorkers = 3

func main() {
    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    var wg sync.WaitGroup
    wg.Add(numWorkers)

    for w := 1; w <= numWorkers; w++ {
        go func(id int) {
            defer wg.Done()
            worker(id, jobs, results)
        }(w)
    }

    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    wg.Wait()

    for r := 1; r <= numJobs; r++ {
        fmt.Println(<-results)
    }
}

Im obigen Beispiel haben wir die Worker-Funktion definiert, die die ausstehenden Aufgaben aus dem Auftragskanal liest, die Aufgaben dann ausführt und die Ergebnisse an den Ergebniskanal sendet. Wir haben einen Jobkanal und einen Ergebniskanal erstellt, um die Funktion des Coroutine-Pools durch die Verteilung von Aufgaben und den Erhalt von Ergebnissen zu implementieren.

In der Hauptfunktion verwenden wir WaitGroup, um darauf zu warten, dass alle Arbeiter (Goroutinen) die Aufgabenausführung abschließen. Anschließend senden wir die auszuführenden Aufgaben an den Jobs-Kanal und schließen den Kanal nach der Ausführung. Abschließend holen wir uns die Berechnungsergebnisse aus dem Ergebniskanal und geben sie aus.

3. Ein effizienter Kombinationsfall von WaitGroup und Coroutine-Pool
Als nächstes werden wir die beiden oben genannten Konzepte kombinieren, um vorzustellen, wie WaitGroup und Coroutine-Pool effizient verwendet werden können, um gleichzeitige Programmierung zu implementieren. Der spezifische Beispielcode lautet wie folgt:

package main

import (
    "fmt"
    "sync"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("Worker", id, "started job", j)
        fib := fibonacci(j)
        fmt.Println("Worker", id, "finished job", j)
        results <- fib
    }
}

func fibonacci(n int) int {
    if n <= 1 {
        return n
    }

    return fibonacci(n-1) + fibonacci(n-2)
}

const numJobs = 5
const numWorkers = 3

func main() {
    var wg sync.WaitGroup
    wg.Add(numWorkers)

    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    for w := 1; w <= numWorkers; w++ {
        go func(id int) {
            defer wg.Done()
            worker(id, jobs, results)
        }(w)
    }

    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    go func() {
        wg.Wait()
        close(results)
    }()

    for r := range results {
        fmt.Println(r)
    }
}

Im obigen Beispiel haben wir ein WaitGroup-Objekt erstellt und den Zähler durch Aufrufen der Add-Methode erhöht. Anschließend haben wir einen Jobkanal und einen Ergebniskanal erstellt, um Aufgaben zu verteilen und Ergebnisse zu erhalten. Wir erstellen eine feste Anzahl von Arbeitern (Goroutinen) und warten mit der Wait-Methode darauf, dass sie ihre Aufgaben erledigen.

In der Hauptfunktion senden wir die auszuführenden Aufgaben an den Jobs-Kanal und schließen den Kanal nach der Ausführung. Anschließend starten wir eine Coroutine, um darauf zu warten, dass alle Mitarbeiter ihre Aufgaben abgeschlossen haben, und schließen den Ergebniskanal, wenn sie abgeschlossen sind. Abschließend geben wir die Berechnungsergebnisse aus, indem wir sie aus dem Ergebniskanal abrufen.

Fazit:
Durch die Kombination von WaitGroup und Coroutine-Pool können wir eine effiziente gleichzeitige Programmierung erreichen. Indem Sie eine WaitGroup verwenden, um auf den Abschluss der Ausführung einer Gruppe von Goroutinen zu warten, können Sie sicherstellen, dass die Haupt-Goroutine weiterhin ausgeführt wird, nachdem alle Aufgaben abgeschlossen sind. Durch die Verwendung des Coroutine-Pools können wir den Aufwand für das häufige Erstellen und Zerstören von Goroutinen vermeiden und die Ausführungseffizienz und Ressourcennutzung des Programms verbessern.

Die Fibonacci-Sequenzberechnung im Codebeispiel ist nur ein Demonstrationsbeispiel und kann je nach spezifischen Anforderungen in tatsächlichen Anwendungen durch andere Aufgaben ersetzt werden. Mit WaitGroup und dem Coroutine-Pool können wir die Anzahl gleichzeitig ausgeführter Aufgaben besser kontrollieren und Rechenressourcen effektiv nutzen.

Obwohl die Go-Sprache umfangreiche Tools und Funktionen für die gleichzeitige Programmierung bietet, müssen Sie bei der Verwendung dennoch vorsichtig sein. Die ordnungsgemäße Verwendung von WaitGroup und dem Coroutine-Pool kann uns dabei helfen, Goroutinen besser zu verwalten und zu planen und eine effiziente gleichzeitige Programmierung zu erreichen.

Das obige ist der detaillierte Inhalt vonEffiziente Kombination aus Golang WaitGroup und Coroutine-Pool. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!