Comment le modèle de travail avec la concurrence et la synchronisation est-il implémenté dans le langage Go?

Dans le langage Go, la concurrence est réalisée à l’aide de threads légers appelés goroutines. Les goroutines sont lancées avec le mot-clé go et fonctionnent en parallèle, tandis que le runtime de Go gère leur planification de manière autonome.

Pour la synchronisation et l’échange de données entre goroutines, plusieurs mécanismes sont utilisés :

• Canaux (channels) — permettent de transmettre des données en toute sécurité entre goroutines, en assurant la synchronisation. Les canaux peuvent être considérés comme des files d’attente qui bloquent l’expéditeur si le canal est plein, et le récepteur si le canal est vide.

• Package sync — contient des primitives de synchronisation telles que mutex (sync.Mutex), variables conditionnelles (sync.Cond), groupes d’attente (sync.WaitGroup) et autres.

Exemple d’utilisation de goroutines et de canaux :

package main
import (
    "fmt"
    "time"
)

func worker(id int, ch chan string) {
    time.Sleep(time.Second)
    ch <- fmt.Sprintf("Travailleur %d terminé", id)
}

func main() {
    ch := make(chan string)
    for i := 1; i <= 3; i++ {
        go worker(i, ch)
    }
    for i := 1; i <= 3; i++ {
        msg := <-ch
        fmt.Println(msg)
    }
}

Ici, trois goroutines s’exécutent en parallèle, et le canal est utilisé pour recevoir les résultats de chacune d’elles.