Comment utiliser Goroutines pour le calcul parallèle dans Go

Comment utiliser Goroutines pour le calcul parallèle dans Go

Présentation :
Le langage Go est un langage de programmation concurrent qui prend en charge nativement le calcul parallèle. Go fournit des Goroutines et des canaux pour implémenter le calcul parallèle. Cet article explique comment utiliser Goroutines pour le calcul parallèle dans Go et fournit quelques exemples de code.

Goroutines :
Goroutine est un thread léger dans le langage Go. Il peut être créé et détruit pendant l'exécution du programme, et le coût de création, de destruction et de changement est très faible. En utilisant Goroutines, nous pouvons implémenter un calcul parallèle efficace dans nos programmes.

Les étapes pour utiliser Goroutines pour le calcul parallèle sont les suivantes :

1. Créer Goroutine :
   Dans le langage Go, vous pouvez créer une Goroutine en utilisant le mot-clé go, et mettre le code qui doit être exécuté en parallèle dans le Goroutine.

Exemple de code :

package main

import (
    "fmt"
    "sync"
)

func calculate(num int, wg *sync.WaitGroup) {
    defer wg.Done()

    result := num * 2
    fmt.Println(result)
}

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 10; i++ {
        wg.Add(1)
        go calculate(i, &wg)
    }

    wg.Wait()
}

Dans l'exemple ci-dessus, nous avons créé une fonction appelée calculate qui prend un entier et l'imprime en le multipliant par 2. Dans la fonction principale, nous créons 10 Goroutines à l'aide d'une boucle et transmettons chaque nombre comme paramètre à la fonction de calcul. Nous utilisons le WaitGroup dans le package de synchronisation pour garantir que toutes les Goroutines sont exécutées.

2. Utilisez les canaux pour transmettre des données :
   Les canaux peuvent être utilisés pour transmettre des données entre Goroutines. En créant un canal et en utilisant l'opérateur fléché <- pour envoyer et recevoir des données sur le canal.

Exemple de code :

package main

import (
    "fmt"
    "sync"
)

func calculate(num int, wg *sync.WaitGroup, result chan<- int) {
    defer wg.Done()

    result <- num * 2
}

func main() {
    var wg sync.WaitGroup
    result := make(chan int)

    for i := 1; i <= 10; i++ {
        wg.Add(1)
        go calculate(i, &wg, result)
    }

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

    for res := range result {
        fmt.Println(res)
    }
}

Dans l'exemple ci-dessus, nous envoyons le résultat de la fonction de calcul via le canal de résultat. Dans la fonction principale, nous utilisons une fonction anonyme pour attendre que tous les Goroutines terminent leur exécution et fermons le canal résultat. Enfin, nous recevons les résultats dans le canal de résultats et les imprimons en utilisant range dans la boucle for.

Résumé :
En utilisant Goroutines et Channels, nous pouvons réaliser un calcul parallèle efficace en langage Go. Les Goroutines peuvent être utilisées pour créer et détruire facilement des tâches informatiques simultanées, et les canaux peuvent être utilisés pour transférer facilement des données. Dans les applications pratiques, nous pouvons créer différents nombres de Goroutines selon les besoins et sélectionner un modèle de calcul parallèle approprié en fonction des caractéristiques de la tâche informatique.

Ce qui précède est une introduction et un exemple de code sur la façon d'utiliser Goroutines pour le calcul parallèle dans Go. J'espère que cet article vous aidera à comprendre la programmation simultanée en langage Go.

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!