Que sont les goroutines ?

Question

Accepted Answer

Une **goroutine** est une fonction légère, s'exécutant de façon concurrente, gérée par l'exécuteur Go. En lancer une est aussi simple que de mettre `go` avant un appel de fonction. Les goroutines sont la fonctionnalité de concurrence signature de Go — beaucoup moins coûteuses que les threads OS, vous pouvez donc en exécuter des milliers ou des millions.

## Lancer une goroutine

```go
func sayHello() {
    fmt.Println("Hello from a goroutine")
}

go sayHello()        // launch concurrently — main does NOT wait for it
go func() {           // or an anonymous function
    fmt.Println("inline goroutine")
}()
```

Le mot-clé `go` démarre la fonction sur une nouvelle goroutine et revient immédiatement — le code appelant continue sans attendre.

## Pourquoi les goroutines sont spéciales : elles sont bon marché

```text
OS thread:  ~1–2 MB of memory each → thousands max
Goroutine:  ~2 KB initial stack (grows as needed) → MILLIONS feasible
The Go runtime SCHEDULES many goroutines onto a small pool of OS threads (M:N).
```

Les goroutines ne sont pas des threads OS — l'ordonnanceur Go multiplex plusieurs goroutines sur quelques threads OS. Cela les rend extraordinairement bon marché, permettant une concurrence massive (par exemple, une goroutine par connexion dans un serveur gérant des millions de connexions).

## Le problème de synchronisation : main peut se terminer trop tôt

```go
func main() {
    go sayHello()    // ❌ main might EXIT before this goroutine runs → nothing printed
    // program ends immediately
}
```

Quand `main` revient, le programme se termine — tuant toutes les goroutines encore en cours. Vous devez coordonner.

## Attendre avec sync.WaitGroup

```go
var wg sync.WaitGroup
for i := 0; i < 3; i++ {
    wg.Add(1)                    // increment the counter
    go func(n int) {
        defer wg.Done()          // decrement when this goroutine finishes
        fmt.Println("worker", n)
    }(i)                          // pass i as an argument (avoid the loop-var capture bug)
}
wg.Wait()                         // BLOCK until all goroutines call Done()
```

`sync.WaitGroup` est le moyen standard d'attendre qu'un ensemble de goroutines se termine.

## Communiquer avec les channels

```go
ch := make(chan string)
go func() { ch <- "result" }()   // send a result on the channel
msg := <-ch                       // receive (blocks until a value arrives)
```

La philosophie Go : **« Ne communiquez pas en partageant la mémoire ; partagez la mémoire en communiquant »** — utilisez les channels pour passer des données entre goroutines plutôt que des variables partagées + des verrous.

## Pourquoi c'est important

Les goroutines sont la fonctionnalité définissante de Go et la raison principale pour laquelle il excelle dans les systèmes concurrents et en réseau.

Leur légèreté extrême (kilobytes vs mégabytes pour les threads, ordonnancées M:N sur les threads OS) rend la concurrence massive pratique et facile — un serveur peut créer une goroutine par requête ou connexion sans préoccupations de ressources, ce qui est difficile ou impossible avec les threads OS.

Comprendre comment les lancer (`go`), le besoin critique de **synchronisation** (main se terminant tue les goroutines ; utilisez `WaitGroup` pour attendre), et la préférence de Go pour la **communication via les channels** plutôt que la mémoire partagée est fondamental pour écrire du Go concurrent correct.

Les goroutines (et les modèles autour d'elles) sont centrales à la proposition de valeur de Go et parmi les sujets les plus importants et les plus fréquemment testés du langage.