Wie können Kanäle und separate Worker die Parallelität in Go im Vergleich zur alleinigen Verwendung von Goroutinen verbessern?

Parallele Verarbeitung in Go

Bei der parallelen Programmierung werden mehrere Aufgaben gleichzeitig ausgeführt, was eine verbesserte Leistung in Anwendungen ermöglicht, die in unabhängige Einheiten unterteilt werden können. Eine Möglichkeit, Parallelität in Go zu erreichen, sind Goroutinen, leichte Threads, die gleichzeitig mit dem Hauptprogramm ausgeführt werden.

Betrachten Sie den folgenden Code:

<code class="go">package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    for i := 0; i < 3; i++ {
        go f(i)
    }

    // prevent main from exiting immediately
    var input string
    fmt.Scanln(&input)
}

func f(n int) {
    for i := 0; i < 10; i++ {
        dowork(n, i)
        amt := time.Duration(rand.Intn(250))
        time.Sleep(time.Millisecond * amt)
    }
}

func dowork(goroutine, loopindex int) {
    // simulate work
    time.Sleep(time.Second * time.Duration(5))
    fmt.Printf("gr[%d]: i=%d\n", goroutine, loopindex)
}</code>

Dieser Code verwendet Goroutinen, um gleichzeitig das f auszuführen Funktion dreimal. Die Dowork-Funktion simuliert etwas Arbeit, indem sie 5 Sekunden lang schläft.

Können Sie davon ausgehen, dass die Dowork-Funktion parallel ausgeführt wird?

Ja, Sie können diese Annahme treffen. Standardmäßig setzt Go GOMAXPROCS auf die Anzahl der verfügbaren Kerne, wodurch mehrere Goroutinen gleichzeitig ausgeführt werden können.

Ist dies ein korrekter Weg, um Parallelität zu erreichen?

Das ist es ein gültiger Weg, um Parallelität zu erreichen, aber es ist möglicherweise nicht der effizienteste Ansatz. Die Verwendung von Goroutinen ohne Synchronisierungsmechanismen kann zu Datenwettläufen und falschen Ergebnissen führen.

Verwendung von Kanälen und separaten Dowork-Workern

Eine strukturiertere und skalierbarere Möglichkeit, Parallelität zu erreichen, ist die Verwendung Kanäle und separate Dowork-Mitarbeiter. Dieser Ansatz stellt sicher, dass jede Goroutine über eine eigene Kopie gemeinsam genutzter Daten verfügt und über Message Passing kommuniziert.

Hier ist ein Beispiel für die Verwendung von Kanälen:

<code class="go">var results = make(chan int) // channel to collect results

func main() {
    // spawn a worker for each goroutine
    for i := 0; i < 3; i++ {
        go worker(i)
    }

    // collect results from the worker goroutines
    for i := 0; i < 10; i++ {
        result := <-results
        fmt.Println("Received result:", result)
    }
}

func worker(n int) {
    for i := 0; i < 10; i++ {
        // perform work and send result through the channel
        res := dowork(n, i)
        results <- res
    }
}</code>

Fazit

Parallelität in Go kann mit Goroutinen erreicht werden. Die Verwendung von Kanälen und separaten Mitarbeitern ist ein strukturierterer und skalierbarerer Ansatz, der die Datenintegrität gewährleistet und die Leistung verbessert.

Das obige ist der detaillierte Inhalt vonWie können Kanäle und separate Worker die Parallelität in Go im Vergleich zur alleinigen Verwendung von Goroutinen verbessern?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!