Comment fonctionnent les channels ?

Question

Accepted Answer

Un **channel** est un conduit typé pour la **communication entre goroutines** — une goroutine envoie des valeurs, une autre les reçoit. Les channels sont la façon sûre pour les goroutines Go de passer des données et de se synchroniser, incarnant la devise « partager la mémoire en communiquant ».

## Créer et utiliser des channels

```go
ch := make(chan int)     // an unbuffered channel of ints

go func() {
    ch <- 42             // SEND a value into the channel (arrow points INTO ch)
}()

value := <-ch            // RECEIVE a value from the channel (arrow points OUT)
fmt.Println(value)       // 42
```

L'opérateur `<-` à la fois envoie (`ch <- v`) et reçoit (`v := <-ch`).

## Channels non bufferisés vs bufferisés

```go
// UNBUFFERED — send blocks until a receiver is ready (synchronization point)
ch := make(chan int)
// sending blocks until another goroutine receives → they "rendezvous"

// BUFFERED — holds up to N values; send blocks only when the buffer is FULL
buf := make(chan int, 3)
buf <- 1; buf <- 2; buf <- 3   // these don't block (buffer has room)
buf <- 4                        // blocks now — buffer is full
```

Les channels **non bufferisés** synchronisent : un envoi attend une réception (et vice versa), les rendant un outil de coordination. Les channels **bufferisés** découplent l'expéditeur et le récepteur jusqu'à la taille du buffer.

## Fermer les channels et parcourir avec range

```go
ch := make(chan int)
go func() {
    for i := 0; i < 3; i++ { ch <- i }
    close(ch)               // signal "no more values" (only the SENDER closes)
}()

for v := range ch {         // receives until the channel is CLOSED
    fmt.Println(v)
}

// the comma-ok form detects a closed channel
v, ok := <-ch               // ok = false if the channel is closed and drained
```

Fermer un channel signale la fin ; `range` sur un channel reçoit jusqu'à ce qu'il soit fermé. **Seul l'expéditeur doit fermer** un channel.

## Pièges courants de deadlock et panic

```go
// ❌ deadlock — sending on an unbuffered channel with no receiver
ch := make(chan int)
ch <- 1                     // 💥 fatal error: all goroutines asleep - deadlock!

// ❌ panic — operations on/after close
close(ch); close(ch)        // 💥 panic: close of closed channel
close(ch); ch <- 1          // 💥 panic: send on closed channel
v := <-closedCh             // ✅ OK — receiving from a closed channel returns the zero value
```

Les deadlocks (tout le monde bloqué) et les panics liés à la fermeture sont des bugs de channel courants à comprendre.

## Channels directionnels (pour des APIs claires)

```go
func producer(out chan<- int) { out <- 1 }   // send-only
func consumer(in <-chan int)  { <-in }         // receive-only
```

## Pourquoi c'est important

Les channels sont le cœur du modèle de concurrence de Go et la façon idiomatique pour les goroutines de communiquer et de se synchroniser — implémentant la philosophie centrale « ne communiquez pas en partageant la mémoire ; partagez la mémoire en communiquant ». Ils vous permettent de passer des données en toute sécurité entre les goroutines concurrentes sans verrous explicites, de construire des pipelines, de distribuer le travail et de signaler l'achèvement.

Comprendre les opérations d'envoi/réception, la distinction cruciale **non bufferisé (synchronisant) vs bufferisé (découplant)**, la sémantique de fermeture (l'expéditeur ferme ; range/comma-ok la détectent), et les pièges courants (**deadlocks** provenant d'envois/réceptions bloqués, **panics** provenant de fermeture deux fois ou d'envoi sur un channel fermé) est essentiel pour écrire une concurrence Go correcte.

Les channels (avec les goroutines) sont centraux à l'identité de Go et parmi les concepts les plus importants et les plus testés du langage.