Ist die Verwendung von „go f(i)“ der optimale Weg, um Parallelität in Go zu erreichen, oder sollten wir alternative Methoden wie Kanäle und dedizierte Mitarbeiter für jede Goroutine erkunden?

Parallele Verarbeitung in Go

Problem:

Bedenken Sie den angegebenen Go-Codeausschnitt:

<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>

Fragen:

1. Können wir davon ausgehen, dass die „Dowork“-Funktion parallel ausgeführt wird?
2. Ist dies ein geeigneter Weg, um Parallelität zu erreichen, oder sollten wir das tun? Kanäle und separate „Dowork“-Worker für jede Goroutine verwenden?

Antwort:

Bezüglich GOMAXPROCS:

In den Versionshinweisen zu Go 1.5 heißt es:

„Standardmäßig werden Go-Programme mit GOMAXPROCS ausgeführt, das auf die Anzahl der verfügbaren Kerne eingestellt ist; in früheren Versionen war es standardmäßig 1.“

Bezüglich Verhindern des Beendens der Hauptfunktion:

Um zu verhindern, dass die „Haupt“-Funktion sofort beendet wird, kann der Typ „WaitGroup“ verwendet werden, insbesondere die Funktion „Wait“.

Bezüglich Parallelität:

Um die parallele Verarbeitung von Funktionsgruppen zu erleichtern, kann eine Hilfsfunktion eingesetzt werden:

<code class="go">import "sync"

// Parallelize executes functions concurrently
func Parallelize(functions ...func()) {
    var waitGroup sync.WaitGroup
    waitGroup.Add(len(functions))

    defer waitGroup.Wait()

    for _, function := range functions {
        go func(f func()) {
            defer waitGroup.Done()
            f()
        }(function)
    }
}</code>

In Ihrem Fall kann Parallelität wie folgt erreicht werden:

<code class="go">func1 := func() {
    f(0)
}

func2 = func() {
    f(1)
}

func3 = func() {
    f(2)
}

Parallelize(func1, func2, func3)</code>

Das obige ist der detaillierte Inhalt vonIst die Verwendung von „go f(i)“ der optimale Weg, um Parallelität in Go zu erreichen, oder sollten wir alternative Methoden wie Kanäle und dedizierte Mitarbeiter für jede Goroutine erkunden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!