Aller au contenu
Encyclopédie informatique Édition 2026

Le langage Go

Partie 3 sur 4

Niveau de lecture :

6La programmation concurrente

6.1Les goroutines

Lancer une tâche en parallèle se fait en ajoutant le mot-clé go devant un appel de fonction. La fonction s’exécute alors dans une goroutine, une tâche très légère gérée par Go lui-même : elle ne réserve au départ que quelques kilo-octets de mémoire, là où un fil d’exécution du système en demande souvent un mégaoctet ou plus (voir les processus). Un programme peut ainsi en faire tourner des centaines de milliers ; Go les répartit automatiquement sur les cœurs du processeur. Un serveur Web en Go crée simplement une goroutine par requête. C’est le planificateur de Go, intégré à chaque programme, qui décide à chaque instant quelle goroutine s’exécute sur quel cœur, et qui met de côté celles qui attendent une réponse du réseau ou du disque, sans que le programmeur ait à s’en soucier.

6.2Les canaux

Pour se coordonner, les goroutines s’échangent des valeurs par des canaux (chan) : l’une y dépose une valeur avec canal <- valeur, une autre la reçoit avec valeur := <-canal, en attendant si nécessaire. On construit ainsi des chaînes de traitement, où chaque étape travaille en parallèle des autres (figure 1).

goroutine lit les fichiers canal « tâches » goroutine analyse goroutine analyse goroutine analyse canal « résultats » goroutine rassemble Les goroutines ne partagent pas de variables : elles s’échangent des messages par des canaux.
Figure 1. Des goroutines reliées par des canaux : chaque étape travaille en parallèle des autres.
func main() {
    var wg sync.WaitGroup
    carres := make(chan int, 3)
    for _, n := range []int{2, 3, 4} {
        wg.Add(1)
        go func() {
            defer wg.Done()
            carres <- n * n          // envoi dans le canal
        }()
    }
    wg.Wait()                         // attendre les trois goroutines
    close(carres)
    for c := range carres {           // réception jusqu'à fermeture
        fmt.Println(c)
    }
}

L’instruction select attend sur plusieurs canaux à la fois, par exemple une réponse ou l’expiration d’un délai. Le paquet context, utilisé partout dans les serveurs, transmet à toutes les goroutines d’une même requête un signal d’annulation : si le client se déconnecte, tout le travail en cours pour lui s’arrête.

6.3Les courses de données

Go n’interdit pas, comme Rust, de partager une variable entre goroutines : si deux d’entre elles la modifient sans précaution, le résultat est imprévisible (exercice 3). Pour ces cas, le paquet sync fournit des verrous (Mutex), et sync/atomic des opérations indivisibles. Surtout, Go fournit un détecteur de courses : en lançant les tests ou le programme avec l’option -race, on obtient un rapport précis dès qu’un accès simultané non protégé se produit. Il est conseillé de l’activer dans tous les tests automatiques.

7Compiler et déployer

Un programme Go se compile en un seul fichier exécutable qui contient tout ce dont il a besoin, y compris le moteur d’exécution des goroutines et le ramasse-miettes : rien à installer sur la machine cible, ni interpréteur, ni bibliothèques. La compilation croisée est intégrée : deux variables d’environnement, GOOS pour le système et GOARCH pour le type de processeur, suffisent pour produire depuis un même ordinateur des exécutables pour Linux, Windows ou macOS, sur processeur Intel ou ARM (figure 2).

GOOS=windows GOARCH=amd64 go build -o outil.exe
GOOS=linux   GOARCH=arm64 go build -o outil
main.go code source go build compilation GOOS, GOARCH linux/amd64 serveur Linux windows/amd64 PC Windows darwin/arm64 Mac récent image de conteneur un fichier quelques mégaoctets, rien d’autre à installer Un seul fichier exécutable, sans dépendance à installer, pour chaque système visé.
Figure 2. Un seul fichier exécutable par système visé, facile à placer dans un conteneur.

Cette simplicité de déploiement explique le succès de Go dans le monde des conteneurs : une image de conteneur peut ne contenir que l’exécutable, quelques mégaoctets au lieu de plusieurs centaines, ce qui accélère les déploiements et réduit la surface d’attaque, c’est-à-dire l’ensemble des composants qu’un attaquant pourrait exploiter. Le ramasse-miettes de Go est conçu pour des pauses très courtes, de l’ordre de la milliseconde ou moins, compatibles avec des serveurs qui doivent répondre vite.

7.1La mémoire sous le capot

Le programmeur Go ne choisit pas où ranger ses données : c’est le compilateur qui décide, par une analyse d’échappement. Une variable qui ne sert qu’à l’intérieur d’une fonction est placée sur la pile, une zone libérée automatiquement à la sortie de la fonction, sans travail pour le ramasse-miettes ; une variable dont l’adresse « s’échappe », par exemple parce qu’elle est renvoyée ou partagée avec une goroutine, est placée dans le tas, que le ramasse-miettes surveille. La commande go build -gcflags=-m affiche ces décisions, utiles pour optimiser un programme très sollicité.

Deux réglages permettent d’adapter le ramasse-miettes : GOGC fixe à partir de quelle croissance de la mémoire il se déclenche, et GOMEMLIMIT, apparu en 2022, lui donne une limite de mémoire à ne pas dépasser. Ce dernier est précieux dans les conteneurs, dont la mémoire est plafonnée : sans lui, un programme Go peut être arrêté brutalement par le système pour avoir dépassé son quota avant même que le ramasse-miettes ne se soit déclenché.

Pour s’exercer

Exercice 5 : livrer un outil pour trois systèmes

Vous avez écrit un petit outil d’inventaire en Go, sur un Mac récent. Vos collègues utilisent des PC sous Windows et des serveurs Linux équipés de processeurs Intel. Quelles commandes lancer ? Que devront-ils installer pour l’utiliser ?

Voir la réponse

GOOS=windows GOARCH=amd64 go build -o inventaire.exe pour les PC, GOOS=linux GOARCH=amd64 go build -o inventaire pour les serveurs, et un simple go build pour le Mac. Les collègues n’ont rien à installer : chaque fichier contient tout le nécessaire. Il est conseillé de publier, avec les exécutables, leurs empreintes cryptographiques, pour que chacun puisse vérifier que le fichier reçu n’a pas été modifié (voir le hachage).