Comment les canaux et les travailleurs séparés peuvent-ils améliorer le parallélisme dans Go par rapport à l'utilisation de goroutines seules ?

Traitement parallèle dans Go

La programmation parallèle implique l'exécution de plusieurs tâches simultanément, ce qui permet d'améliorer les performances des applications qui peuvent être divisées en unités indépendantes. Une façon d'obtenir le parallélisme dans Go consiste à utiliser des goroutines, des threads légers qui s'exécutent simultanément avec le programme principal.

Considérez le code suivant :

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

Ce code utilise des goroutines pour exécuter simultanément le f fonctionner trois fois. La fonction dowork simule un certain travail en dormant pendant 5 secondes.

Pouvez-vous supposer que la fonction dowork s'exécutera en parallèle ?

Oui, vous pouvez faire cette hypothèse. Par défaut, Go définit GOMAXPROCS sur le nombre de cœurs disponibles, ce qui permet à plusieurs goroutines de s'exécuter simultanément.

Est-ce une manière correcte d'obtenir le parallélisme ?

C'est un moyen valable d’atteindre le parallélisme, mais ce n’est peut-être pas l’approche la plus efficace. L'utilisation de goroutines sans mécanismes de synchronisation peut entraîner des courses de données et des résultats incorrects.

Utiliser des canaux et des tâches de travail séparées

Une manière plus structurée et évolutive d'obtenir le parallélisme consiste à utiliser canaux et travailleurs de travaux séparés. Cette approche garantit que chaque goroutine dispose de sa propre copie de données partagées et communique par transmission de messages.

Voici un exemple utilisant des canaux :

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

Conclusion

Le parallélisme en Go peut être réalisé avec des goroutines. L'utilisation de canaux et de travailleurs distincts constitue une approche plus structurée et évolutive qui garantit l'intégrité des données et améliore les performances.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!