Les channels dans Go

Communication entre goroutines

Maintenant que nous savons ce que sont les goroutines, voyons comment elles peuvent communiquer entre elles. C’est ici que les channels entrent en jeu. Dans le langage Go, les channels sont des mécanismes sûrs et synchronisés pour transférer des données entre goroutines.

Un channel est comme un tuyau à travers lequel les goroutines peuvent envoyer et recevoir des valeurs.

Pour créer un channel, on utilise la fonction make avec le type de données que le channel va transporter.

Voyons ensemble un exemple simple où nous utilisons un channel pour transmettre un message entre la routine principale et une goroutine :

package main

import (
    "fmt"
)

// Fonction qui envoie un message sur un channel
func sendMessage(ch chan string) {
    ch <- "Hello depuis la goroutine"
}

func main() {
    // Création d'un channel de type string
    messageChannel := make(chan string)

    // Lancement d'une goroutine qui envoie un message
    go sendMessage(messageChannel)

    // Réception du message depuis le channel
    msg := <-messageChannel
    fmt.Println("Message reçu :", msg)
}

Dans cet exemple, nous avons un channel messageChannel de type string. La fonction sendMessage envoie un message sur ce channel avec ch <- 'Hello depuis la goroutine'. Dans la fonction main, nous recevons ce message avec msg := <-messageChannel et l’affichons.

Communication bidirectionnels ou unidirectionnels

Les channels peuvent également être bidirectionnels ou unidirectionnels.

Par défaut, un channel est bidirectionnel, ce qui signifie qu’il peut envoyer et recevoir des données. Vous pouvez également spécifier un channel comme étant uniquement pour l’envoi ou la réception, ce qui renforce la sécurité du code.

Voyons un autre exemple où nous utilisons un channel pour transférer des données entre deux goroutines :

package main

import (
    "fmt"
)

// Fonction pour envoyer des nombres sur un channel
func sendNumbers(ch chan int) {
    for i := 1; i <= 5; i++ {
        ch <- i
    }
    close(ch) // Ferme le channel après l'envoi des données
}

// Fonction pour recevoir des nombres depuis un channel
func receiveNumbers(ch chan int) {
    for num := range ch {
        fmt.Println("Reçu :", num)
    }
}

func main() {
    numbersChannel := make(chan int)

    go sendNumbers(numbersChannel)
    receiveNumbers(numbersChannel)
}

Dans cet exemple, la fonction sendNumbers envoie les nombres de 1 à 5 sur le channel numbersChannel, puis ferme le channel avec close(ch). La fonction receiveNumbers reçoit les nombres depuis le channel et les affiche jusqu’à ce que le channel soit fermé.

L’utilisation de range ch dans la boucle permet de recevoir automatiquement les valeurs jusqu’à ce que le channel soit fermé, évitant ainsi les blocages potentiels.

Tapez la commande suivante :

go run main.go

Voici le résultat :

Reçu : 1
Reçu : 2
Reçu : 3
Reçu : 4
Reçu : 5

Les channels sont essentiels pour écrire du code concurrent en Go, car ils offrent un moyen sûr et efficace de synchroniser les goroutines et de partager des données entre elles.