Comment utiliser les Goroutines et les canaux dans Golang

Comment utiliser les Goroutines et les canaux dans Golang

Golang est un langage de programmation haute performance particulièrement adapté à la gestion de tâches simultanées. Dans Golang, Goroutines et Channels sont deux concepts très importants qui peuvent nous aider à réaliser la concurrence et la collaboration.

Les Goroutines sont l'unité de base des tâches simultanées dans Golang. Il s'agit d'un thread léger. Par rapport aux threads traditionnels, les Goroutines sont très peu coûteuses à créer et à détruire, et des milliers de Goroutines peuvent être facilement créées. En utilisant Goroutines, nous pouvons effectuer plusieurs tâches en même temps et améliorer les performances du programme.

Voici un exemple d'utilisation de Goroutines :

package main

import (
    "fmt"
    "time"
)

func task(id int) {
    for i := 0; i < 5; i++ {
        fmt.Printf("Goroutine %d: %d
", id, i)
        time.Sleep(time.Millisecond * 100)
    }
}

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

    // 保证 main 函数不会结束
    time.Sleep(time.Second * 1)
}

Dans l'exemple ci-dessus, nous avons créé trois Goroutines pour exécuter la fonction de tâche. Chaque goroutine imprime son propre identifiant et un numéro incrémentiel. Nous utilisons la fonction time.Sleep pour mettre en pause chaque Goroutine pendant un certain temps afin d'observer l'effet de l'exécution simultanée.

Exécutez le code ci-dessus, vous verrez un résultat similaire à celui-ci :

Goroutine 0: 0
Goroutine 1: 0
Goroutine 2: 0
Goroutine 0: 1
Goroutine 1: 1
Goroutine 2: 1
...

Comme le montre le résultat, les trois Goroutines sont exécutées en même temps et il n'y a aucun ordre entre elles. C'est la puissance des Goroutines. Ils peuvent être exécutés simultanément dans différents threads, améliorant ainsi l'efficacité d'exécution du programme.

Pour communiquer entre Goroutines, nous pouvons utiliser des canaux. Channel est un canal de type sécurisé qui peut être utilisé pour transmettre des données et synchroniser l'exécution de Goroutines.

Voici un exemple utilisant des canaux :

package main

import "fmt"

func sum(numbers []int, result chan int) {
    sum := 0
    for _, number := range numbers {
        sum += number
    }
    result <- sum
}

func main() {
    numbers := []int{1, 2, 3, 4, 5}

    result := make(chan int)
    go sum(numbers[:3], result)
    go sum(numbers[3:], result)

    x, y := <-result, <-result
    total := x + y
    fmt.Println("Total:", total)
}

Dans l'exemple ci-dessus, nous avons défini une fonction somme qui reçoit une tranche et un canal. La fonction sum calcule la somme des nombres dans une tranche et écrit le résultat sur le canal.

Dans la fonction principale, nous créons un canal et utilisons deux Goroutines pour calculer respectivement la somme de la première moitié et de la seconde moitié de la tranche. Nous utilisons l'opérateur <- pour lire le résultat du canal et additionner les résultats des deux sommes.

Exécutez le code ci-dessus, vous verrez le résultat :

Total: 15

Grâce à Channel, nous pouvons réaliser le partage de données et la communication entre les Goroutines. Il garantit la synchronisation entre les Goroutines afin que les Goroutines exécutés simultanément puissent accéder et modifier en toute sécurité les données partagées.

Résumé : Les Goroutines et les canaux dans Golang sont des concepts de programmation simultanée très importants. Les Goroutines peuvent être facilement créées et détruites et peuvent effectuer efficacement des tâches simultanées. Les canaux peuvent être utilisés pour transmettre des données et se synchroniser entre les Goroutines. En maîtrisant l'utilisation des Goroutines et des canaux, nous pouvons exploiter pleinement les fonctionnalités de concurrence de Golang et améliorer les performances et la fiabilité du programme.

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!