select, écouter plusieurs voix select, listening to many voices

Quand plusieurs channels parlent en même temps, select choisit celui qui est prêt. Avec default, il n'attend pas ; avec time.After, il pose un délai. Et un select{} sans cas, c'est le blocage éternel — parfois voulu, souvent un bug. When several channels speak at once, select picks the one that's ready. With default, it doesn't wait; with time.After, it sets a deadline. And a select{} with no case is an eternal block — sometimes intended, often a bug.

Audience
Dev qui sait lire un channel et veut en écouter plusieurs sans rester sourd à l'annulation Dev who can read one channel and wants to watch several without going deaf to cancellation
ChapitresChapters
5
LectureReading
≈ 17 min
NiveauLevel
●●○○
Date
Oct 2026 Oct 2026

selectMultiplexageTimeout

SommaireContents ·
№ 01CadrageFraming3 min

Une réception n'écoute qu'une voix. Le vrai code en a plusieurs.A receive listens to one voice. Real code has several.

Au numéro précédent, un channel transmettait une valeur d'une main à l'autre. Mais une goroutine n'attend presque jamais une seule chose : elle guette un résultat, tout en restant à l'écoute d'une annulation, d'un délai, d'un second producteur. Avec un simple <-ch, on se fige sur la première voix et on devient sourd aux autres. Il faut un standard téléphonique : un point d'attente qui surveille plusieurs channels à la fois et donne la main au premier qui parle. C'est select.Last issue, a channel handed a value from one hand to another. But a goroutine almost never waits on a single thing: it watches for a result while staying alert to a cancellation, a deadline, a second producer. With a plain <-ch, you freeze on the first voice and go deaf to the rest. You need a switchboard: one waiting point that watches several channels at once and yields to whichever speaks first. That's select.

Une seule réception : sourd à tout le resteA single receive: deaf to everything else
func wait(results <-chan int, done <-chan struct{}) int {
    res := <-results       // on se fige sur UNE voix…
    return res             // … et on n'entend ni l'annulation, ni l'horloge
}                          // si results tarde, plus rien ne nous réveille
Le standard téléphoniqueThe switchboard
<-results
la donnéethe data
en attentewaiting
<-done
l'annulationcancellation
prêt ✓ready ✓
<-time.After
le délaithe deadline
en attentewaiting

select met plusieurs réceptions en attente simultanée, puis débloque dès qu'une seule est prête — ici l'annulation arrive avant la donnée, et c'est elle qu'on sert. Les autres restent en attente, intactes, pour le prochain tour.select puts several receives on simultaneous watch, then unblocks the moment just one is ready — here cancellation arrives before the data, so that's the one served. The others stay waiting, untouched, for the next round.

Le réflexe du numéroThe issue's reflex

« select attend le premier prêt, et n'en sert qu'un. » Tout le numéro tient là : il choisit un cas, exécute son corps, puis rend la main. Pour écouter en boucle, c'est à toi de l'envelopper dans un for — et c'est précisément là que se cachent les pièges."select waits for the first ready one, and serves only one." The whole issue lives there: it picks a case, runs its body, then hands back control. To listen on a loop, you wrap it in a for yourself — and that's exactly where the traps hide.

Écouter n'est pas recevoir.Listening isn't receiving.

Un select n'aspire pas tous les channels prêts : il en choisit un, et un seul, par exécution. Les valeurs des autres cas ne sont pas consommées — elles restent dans leur channel. C'est la différence avec un range, qui draine un channel jusqu'au bout. Le select, lui, prend une décision ponctuelle ; l'orchestration dans la durée, c'est le for autour qui la porte.A select doesn't drain every ready channel: it picks one, and only one, per run. The other cases' values aren't consumed — they stay in their channels. That's the difference from a range, which drains one channel to the end. select makes a one-shot decision; sustained orchestration is carried by the for around it.

№ 02La mécaniqueThe mechanics5 min

Deux cas prêts en même temps ? Go tranche au hasard.Two cases ready at once? Go decides at random.

On lit un select de haut en bas et on suppose, naturellement, que l'ordre des cas est un ordre de priorité. Il n'en est rien. select bloque jusqu'à ce qu'au moins un cas soit prêt ; et si plusieurs le sont au même instant, il en choisit un de façon uniformément aléatoire. Ce n'est pas un détail d'implémentation : c'est une garantie du langage, pensée pour qu'aucun channel bavard n'affame ses voisins. Le comprendre, c'est cesser d'écrire des priorités qui n'existent pas.You read a select top to bottom and naturally assume case order means priority order. It doesn't. select blocks until at least one case is ready; and if several are ready at the same instant, it picks one uniformly at random. That's not an implementation detail: it's a language guarantee, designed so no chatty channel starves its neighbours. Grasp it and you stop writing priorities that don't exist.

L'ordre des cas n'est PAS un ordre de prioritéCase order is NOT priority order
select {
case v := <-a:     // si a ET b sont prêts au même instant…
    use(v)
case v := <-b:     // … Go choisit l'un OU l'autre, au hasard, uniformément
    use(v)
}
// aucun ordre, aucune priorité — c'est voulu : ça évite la famine

Quand un seul cas est prêt, select le prend, sans surprise. Mais quand a et b le sont ensemble, le runtime tire au sort — uniformément. Aucun cas n'est « au-dessus » d'un autre. Si ton code dépend de l'ordre d'écriture des cas, il a un bug latent qui se révélera le jour où les deux channels seront prêts en même temps.When a single case is ready, select takes it, no surprise. But when a and b are ready together, the runtime draws lots — uniformly. No case sits "above" another. If your code relies on the written order of cases, it has a latent bug that surfaces the day both channels are ready at once.

Envoyer aussi, pas que recevoirSending too, not just receiving

Un cas de select peut être un envoi autant qu'une réception : case ch <- v: est prêt quand un receveur (ou une place de buffer) est disponible. C'est exactement le mécanisme qui fermait la fuite du Vol. 1 №03 : case ch <- v: face à case <-ctx.Done():, la goroutine sort par celui qui se présente. Le select arbitre les deux sens du channel.A select case can be a send as much as a receive: case ch <- v: is ready when a receiver (or a buffer slot) is available. It's exactly the mechanism that closed the Vol. 1 №03 leak: case ch <- v: against case <-ctx.Done():, the goroutine leaves by whichever shows up. select arbitrates both directions of the channel.

Un channel fermé est toujours prêt.A closed channel is always ready.

Recevoir sur un channel fermé ne bloque jamais : ça rend aussitôt la valeur nulle et ok=false. Dans un select en boucle, un cas dont le channel est fermé devient donc prêt à chaque tour — et part en boucle folle si tu ne le neutralises pas. L'astuce idiomatique : mettre cette variable de channel à nil, ce qui rend son cas éternellement non prêt. On y reviendra au prochain numéro, où fermer devient un signal à part entière.Receiving on a closed channel never blocks: it immediately returns the zero value and ok=false. In a looping select, a case whose channel is closed becomes ready every single round — and spins out of control unless you disable it. The idiomatic trick: set that channel variable to nil, which makes its case eternally not-ready. We'll return to it next issue, where closing becomes a signal in its own right.

L'ordre des cas est une mise en page, pas une file d'attente.Case order is a layout, not a queue.
№ 03default & time.Afterdefault & time.After5 min

Deux façons de ne pas attendre pour toujours : tout de suite, ou jusqu'à une heure.Two ways not to wait forever: right now, or until a deadline.

Par défaut, un select bloque jusqu'à ce qu'un cas soit prêt. Deux ajouts changent radicalement ce comportement, et il ne faut jamais les confondre. default s'exécute quand aucun autre cas n'est prêt à l'instant précis de l'évaluation : le select devient un essai instantané, sans attente. time.After, lui, est un cas comme un autre — un channel qui devient prêt après un délai : le select attend, mais pas au-delà de cette échéance. L'un dit « maintenant ou jamais », l'autre « dans la limite du temps imparti ».By default, a select blocks until a case is ready. Two additions change that behaviour radically, and they must never be confused. default runs when no other case is ready at the exact instant of evaluation: the select becomes an instant attempt, no waiting. time.After is just another case — a channel that becomes ready after a delay: the select waits, but no longer than that deadline. One says 'now or never,' the other 'within the time allotted.'

« prêt ? si non, je passe » — zéro attente'ready? if not, I move on' — zero wait
select {
case v := <-ch:
    use(v)             // une valeur était prête : on la prend
default:
    // RIEN n'était prêt → on ne bloque pas, on passe
    return ErrWouldBlock
}
// default fait du select un essai instantané : « prêt ? sinon tant pis »

Avec default, le select ne bloque jamais : il regarde si un cas est prêt à cet instant, et sinon prend la branche par défaut. C'est l'idiome du try-receive et du try-send — sonder un channel sans s'y suspendre. Puissant, mais à manier avec soin : un default dans une boucle serrée, sans rien pour ralentir, transforme le select en attente active qui brûle un cœur entier.With default, the select never blocks: it checks whether a case is ready at that instant, and otherwise takes the default branch. It's the try-receive and try-send idiom — probing a channel without suspending on it. Powerful, but handle with care: a default in a tight loop, with nothing to slow it, turns the select into a busy-wait that burns a whole core.

default n'est pas un cas comme les autresdefault isn't a case like the others

La distinction clé : time.After participe au tirage au sort des cas prêts, default non. default n'est consulté qu'après avoir constaté qu'aucun autre cas n'est prêt — c'est un repli, jamais un concurrent. Conséquence pratique : un select avec default ne bloque pas une nanoseconde, tandis qu'un select avec time.After bloque, potentiellement jusqu'au délai. « Ne pas attendre » et « attendre avec une limite » sont deux intentions opposées — choisis le mot qui dit la tienne.The key distinction: time.After takes part in the lottery among ready cases, default doesn't. default is consulted only after finding no other case ready — it's a fallback, never a competitor. Practical upshot: a select with default doesn't block for a nanosecond, while a select with time.After blocks, potentially up to the delay. "Don't wait" and "wait with a limit" are opposite intents — pick the word that states yours.

default regarde l'instant. time.After regarde la montre.default watches the instant. time.After watches the clock.
№ 04Le piègeThe trap3 min

time.After dans une boucle : un timer neuf à chaque tour, et aucun ramassé.time.After in a loop: a fresh timer every round, and none reclaimed.

time.After est parfait pour un timeout unique. Glissé dans un for-select, il devient un piège discret. Chaque tour de boucle qui n'expire pas crée pourtant un timer — et ce timer, jusqu'à Go 1.22, restait vivant dans le runtime jusqu'à la fin de son délai, qu'on l'écoute encore ou non. Sur un stream actif, c'est des milliers de minuteries d'une minute qui s'accumulent : mémoire qui gonfle, planificateur qui rame. La fuite n'est pas dans ta logique, elle est dans la répétition de l'appel.time.After is perfect for a one-off timeout. Slipped into a for-select, it becomes a quiet trap. Every loop iteration that doesn't expire still creates a timer — and that timer, through Go 1.22, stayed alive in the runtime until its delay elapsed, whether you were still listening or not. On an active stream, that's thousands of one-minute timers piling up: memory swelling, scheduler dragging. The leak isn't in your logic, it's in the repetition of the call.

Un timer créé, jamais réutilisé, rarement ramasséA timer created, never reused, rarely reclaimed
for {
    select {
    case v := <-stream:
        handle(v)                       // cas fréquent : on passe ici sans cesse
    case <-time.After(time.Minute):     // un NOUVEAU timer à CHAQUE tour…
        return ErrIdle                  // … qui vit jusqu'à expiration, non ramassé
    }
}
// ≤ Go 1.22 : des milliers de timers d'une minute s'empilent sous charge

À chaque passage par case v := <-stream, le time.After de l'autre cas a déjà alloué son timer — abandonné aussitôt, mais pas libéré. Le délai d'une minute reste armé dans le runtime jusqu'à expiration. Mille messages par seconde, soixante mille timers en vol. Rien ne plante ; la consommation mémoire monte en pente douce, et un profil pprof heap te montre la pile fautive. (Depuis Go 1.23, un timer qui n'est plus référencé est ramassé avant son expiration : la traînée ne s'accumule plus, mais chaque tour alloue encore un timer et son channel.)Each time through case v := <-stream, the other case's time.After has already allocated its timer — abandoned at once, but not freed. The one-minute delay stays armed in the runtime until it expires. A thousand messages a second, sixty thousand timers in flight. Nothing crashes; memory climbs on a gentle slope, and a pprof heap profile shows you the offending stack. (Since Go 1.23, a timer that's no longer referenced is collected before it fires: the trail no longer piles up, but each iteration still allocates a timer and its channel.)

Le select vide, l'autre extrêmeThe empty select, the other extreme

À l'opposé du default qui ne bloque jamais, un select sans aucun cas bloque pour l'éternité. Parfois voulu — garer la goroutine principale pendant que d'autres travaillent — mais le plus souvent c'est un bug : une attente dont aucun channel ne pourra jamais la tirer. Si toutes les goroutines y aboutissent, le runtime crie deadlock ; sinon, c'est une fuite de plus, silencieuse.The opposite of default that never blocks: a select with no cases at all blocks for eternity. Sometimes intended — parking the main goroutine while others work — but more often a bug: a wait no channel can ever release. If every goroutine ends up there, the runtime shouts deadlock; otherwise, it's one more silent leak.

Go 1.23 a désarmé le piège — à moitié.Go 1.23 half-disarmed the trap.

Depuis Go 1.23 (août 2024), un timer de time.After devenu inatteignable peut être ramassé avant même d'expirer : la fuite mémoire des boucles serrées s'en trouve largement éteinte. C'est le pendant exact du correctif de la variable de boucle en Go 1.22 — le langage rattrape un footgun historique. Mais comme pour la boucle, connais le piège avant de faire confiance au correctif : sur tout module en go.mod antérieur, et pour le coût d'allocation par tour, le timer nommé reste la bonne réponse.Since Go 1.23 (Aug 2024), a time.After timer that becomes unreachable can be collected before it even fires: the tight-loop memory leak is largely extinguished. It's the exact counterpart to Go 1.22's loop-variable fix — the language catching up with a historical footgun. But as with the loop, know the trap before you trust the fix: on any module with an older go.mod, and for the per-iteration allocation cost, the named timer stays the right answer.

Un timeout, ça s'écrit une fois. Dans une boucle, ça se réarme — ça ne se recrée pas.A timeout is written once. In a loop, you rearm it — you don't recreate it.
№ 05Bilan & éditoWrap-up & editorial2 min

Avec select, attendre cesse d'être subi. Ça devient un choix.With select, waiting stops being suffered. It becomes a choice.

Un channel seul t'impose sa voix : tu attends, ou tu n'attends pas. select renverse le rapport — c'est toi qui décides quelles voix comptent, et selon quelle règle tu réponds à la première. Quatre points tiennent tout le mécanisme : il sert un seul cas prêt, l'ordre des cas n'est pas une priorité, default et time.After disent deux intentions opposées, et un timeout en boucle veut un timer nommé.A lone channel imposes its voice: you wait, or you don't. select flips the relationship — you decide which voices count, and by what rule you answer the first. Four points hold the whole mechanism: it serves one ready case, case order isn't priority, default and time.After state opposite intents, and a looping timeout wants a named timer.

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
Le premier prêtThe first readySert un seul cas, puis rend la main. Boucle-le avec for.Serves one case, then returns. Loop it with for.Tu attends qu'il draine ou réécoute seul : il ne fait ni l'un ni l'autre.You expect it to drain or re-listen by itself: it does neither.
L'ordreOrderPlusieurs cas prêts → choix uniformément aléatoire.Several cases ready → uniformly random choice.Tu codes une priorité par l'ordre ; le bug surgit quand deux sont prêts.You code priority by order; the bug fires when two are ready.
default ≠ time.Afterdefault : ne pas attendre. time.After : attendre, mais borné.default: don't wait. time.After: wait, but bounded.default en boucle serrée = attente active qui brûle un cœur.default in a tight loop = a busy-wait burning a core.
Timeout en boucleLooping timeoutUn time.NewTimer hoisté + Reset, pas un time.After par tour.A hoisted time.NewTimer + Reset, not a per-iteration time.After.Les timers s'empilent (≤ Go 1.22) ; allocation à chaque itération.Timers pile up (≤ Go 1.22); an allocation every iteration.
Le channel te donnait une voix à entendre. select te rend l'arbitrage entre toutes.The channel gave you one voice to hear. select hands you the arbitration among them all.
Mot de l'éditeurFrom the editor

Le bon code concurrent ne subit pas l'attente. Il la met en scène.Good concurrent code doesn't suffer waiting. It stages it.

Sans select, l'attente est un accident : on bloque sur le premier <-ch venu, et tout le reste du monde — l'annulation, le délai, le second résultat — devient inaudible. C'est la posture qui produit les goroutines qui fuient et les services qui se figent. select transforme ce blocage passif en décision explicite : voici les voix que j'écoute, voici comment je réponds à la première, voici ma porte de sortie si aucune ne vient. Rien de magique — c'est juste le moment où l'on cesse d'attendre une chose pour orchestrer un ensemble. Le débutant écrit <-ch et espère ; le sénior écrit un select et décrit ce qui peut arriver.Without select, waiting is an accident: you block on the first <-ch that comes, and the whole rest of the world — the cancellation, the deadline, the second result — goes inaudible. That's the posture that produces leaking goroutines and freezing services. select turns that passive block into an explicit decision: here are the voices I'm listening to, here's how I answer the first, here's my exit if none comes. Nothing magical — it's just the moment you stop awaiting one thing and start orchestrating a set. The beginner writes <-ch and hopes; the senior writes a select and describes what can happen.

Prochain numéro : fermer un channel. On a beaucoup envoyé et reçu ; reste à dire « il n'y aura plus rien ». close n'efface pas le channel — c'est une diffusion : tout récepteur en range sort, tout <-ch rend aussitôt la valeur nulle et ok=false. D'où le cas « toujours prêt » qu'on a croisé au chapitre 2. Mais fermer a ses règles dures : envoyer sur un channel fermé panique, fermer deux fois aussi — alors seul l'émetteur ferme, jamais le récepteur. La dernière pièce de la mécanique des channels.Next issue: closing a channel. We've sent and received plenty; what's left is to say 'nothing more is coming.' close doesn't erase the channel — it's a broadcast: every range receiver exits, every <-ch immediately returns the zero value and ok=false. Hence the 'always ready' case we met in chapter 2. But closing has hard rules: sending on a closed channel panics, closing twice panics too — so only the sender closes, never the receiver. The last piece of the channel machinery.