Fermer, c'est diffuser Closing is broadcasting

close ne détruit pas un channel : il annonce qu'il n'y aura plus rien. Tous les récepteurs en range sortent, tous les <-ch rendent la valeur nulle et ok=false. Mais envoyer sur un channel fermé panique — d'où la règle : seul l'émetteur ferme, jamais le récepteur. close doesn't destroy a channel: it announces nothing more is coming. Every range receiver exits, every <-ch returns the zero value and ok=false. But sending on a closed channel panics — hence the rule: only the sender closes, never the receiver.

Audience
Dev qui envoie et reçoit sur des channels et veut signaler la fin sans paniquer Dev who sends and receives on channels and wants to signal the end without panicking
ChapitresChapters
5
LectureReading
≈ 16 min
NiveauLevel
●●○○
Date
Nov 2026 Nov 2026

closeBroadcastrange

SommaireContents ·
№ 01CadrageFraming3 min

Fermer un channel ne le détruit pas. Ça annonce la fin.Closing a channel doesn't destroy it. It announces the end.

On a passé deux numéros à faire circuler des valeurs : transmettre, choisir, attendre. Reste le dernier geste — dire « il n'y aura plus rien ». On l'imagine volontiers comme une destruction, un free() de channel. C'est l'inverse : close n'efface rien et ne libère aucune mémoire. C'est un signal, et un signal particulier — il ne s'adresse pas à un receveur, mais à tous à la fois. Là où un envoi parle à une seule oreille, close diffuse. C'est la seule opération des channels qui soit un broadcast.We've spent two issues moving values around: handing over, choosing, waiting. One last gesture remains — saying 'nothing more is coming.' It's tempting to picture it as destruction, a channel free(). It's the opposite: close erases nothing and frees no memory. It's a signal, and a peculiar one — it speaks not to one receiver, but to all of them at once. Where a send talks to a single ear, close broadcasts. It's the only channel operation that is a broadcast.

Signaler N goroutines à la main : il faut compter justeSignalling N goroutines by hand: you must count right
// arrêter 3 workers en leur envoyant un signal chacun
for i := 0; i < 3; i++ {
    quit <- struct{}{}     // un envoi PAR worker — il faut connaître N
}                          // un de trop : on bloque ; un de moins : un reste
Fermer : une annonce, entendue par tousClosing: one announcement, heard by all
close(quit)                // une annonce, entendue par TOUS
// chaque worker fait <-quit et se réveille en même temps
// pas de compte à tenir : N peut être 3, 300, ou inconnu
Une annonce, plusieurs oreillesOne announcement, many ears
close(ch)
l'émetteurthe sender
⟶
<-ch #1
réveillé ✓woken ✓
<-ch #2
réveillé ✓woken ✓
<-ch #3
réveillé ✓woken ✓

Un seul close(ch) réveille toutes les goroutines bloquées sur <-ch, en même temps, sans qu'on ait à savoir combien elles sont. C'est ce qui fait du channel fermé le signal d'arrêt idiomatique : on ne notifie pas un par un, on déclare une bonne fois.A single close(ch) wakes every goroutine blocked on <-ch, all at once, without your knowing how many there are. That's what makes the closed channel the idiomatic stop signal: you don't notify one by one, you declare it once and for all.

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

« Fermer, c'est dire ‹ plus rien › à tout le monde — et c'est l'émetteur qui le dit. » close est un broadcast côté production : celui qui envoie est le seul à savoir qu'il a fini, donc le seul légitime à fermer. Tout le numéro découle de cette asymétrie, et de ce qui panique quand on l'enfreint."Closing means saying 'no more' to everyone — and it's the sender who says it." close is a broadcast on the producing side: the one sending is the only one who knows it's done, so the only one entitled to close. The whole issue follows from that asymmetry, and from what panics when you break it.

Fermer n'est pas obligatoire.Closing isn't mandatory.

Un channel n'a pas besoin d'être fermé pour être ramassé : le GC s'en occupe quand plus personne ne le référence. On ne ferme que pour signaler — pour qu'un range s'arrête, ou qu'un broadcast d'arrêt parte. Fermer « par hygiène » un channel que personne n'attend ne sert à rien, et fermer celui qu'on ne possède pas est une faute. La question n'est jamais « ai-je fermé ? » mais « ai-je quelque chose à annoncer, et suis-je celui qui l'annonce ? ».A channel needn't be closed to be collected: the GC handles it once nothing references it. You close only to signal — so a range stops, or a stop-broadcast fires. Closing 'for hygiene' a channel no one awaits does nothing, and closing one you don't own is a mistake. The question is never 'did I close?' but 'do I have something to announce, and am I the one announcing it?'

№ 02La diffusionThe broadcast5 min

Un channel fermé ne bloque plus. Il rend la valeur nulle, à l'infini.A closed channel stops blocking. It returns the zero value, forever.

Recevoir d'un channel ouvert mais vide bloque ; recevoir d'un channel fermé ne bloque jamais. Une fois drainé de ses dernières valeurs, il rend instantanément la valeur nulle du type, autant de fois qu'on lit. C'est ce qui fait la puissance — et le danger — de close. Deux idiomes l'exploitent proprement : range, qui boucle puis sort tout seul à la fermeture, et la forme à deux retours v, ok, où ok=false dit « ceci n'est pas une donnée, c'est la fin ».Receiving from an open but empty channel blocks; receiving from a closed channel never blocks. Once drained of its last values, it instantly returns the type's zero value, as many times as you read. That's what makes close powerful — and dangerous. Two idioms use it cleanly: range, which loops then exits on its own at close, and the two-result form v, ok, where ok=false says 'this isn't data, it's the end.'

close est la condition d'arrêt de la boucleclose is the loop's stop condition
for v := range ch {        // boucle tant que des valeurs arrivent
    handle(v)              // … vide d'abord ce qui reste dans le buffer
}                          // … puis SORT toute seule à la fermeture
// pas de condition à écrire : close(ch) est la condition d'arrêt

for v := range ch consomme les valeurs une à une, vide ce qui restait dans le buffer, puis se termine dès que le channel est fermé — sans break, sans drapeau. C'est l'idiome du consommateur : le producteur ferme, le consommateur sort. Oublier le close côté producteur, et ce range ne rend jamais la main : c'est exactement la goroutine qui fuit du Vol. 1 №03, vue de l'autre bout du channel.for v := range ch consumes values one by one, drains whatever was left in the buffer, then ends the moment the channel is closed — no break, no flag. It's the consumer idiom: the producer closes, the consumer exits. Forget the close on the producer side, and this range never returns: it's exactly the leaking goroutine from Vol. 1 №03, seen from the other end of the channel.

Le done channel : fermer pour signalerThe done channel: close to signal

Quand on ne transporte aucune donnée, juste un signal, on déclare done := make(chan struct) et l'on n'y envoie jamais : on le ferme. Toute goroutine bloquée sur <-done se débloque d'un coup. C'est le mécanisme exact que context.Context expose via ctx.Done() : un channel qu'on ne fait que fermer. Le « signal » de Go, c'est une fermeture.When you carry no data, just a signal, you declare done := make(chan struct) and never send on it: you close it. Every goroutine blocked on <-done unblocks at once. It's the exact mechanism context.Context exposes via ctx.Done(): a channel that's only ever closed. Go's "signal" is a close.

Fermé, donc toujours prêt.Closed, hence always ready.

On l'a vu au numéro select : un cas dont le channel est fermé est prêt à chaque tour, puisque la réception ne bloque plus. C'est précisément ce qui fait marcher le done channel dans un select — la branche <-done devient joignable instantanément à la fermeture. Mais c'est aussi le piège de la boucle folle si tu continues d'écouter un channel de données fermé : là, l'astuce est de mettre sa variable à nil pour neutraliser le cas.We saw it in the select issue: a case whose channel is closed is ready every round, since the receive no longer blocks. That's precisely what makes the done channel work inside a select — the <-done branch becomes instantly reachable on close. But it's also the busy-loop trap if you keep listening to a closed data channel: there, the trick is to set its variable to nil to disable the case.

Un channel ouvert te fait attendre. Un channel fermé te répond toujours — la même chose : « c'est fini ».An open channel makes you wait. A closed channel always answers — the same thing: "it's over."
№ 03Les règles duresThe hard rules4 min

Trois façons de fermer qui paniquent. Une seule règle pour les éviter.Three ways to close that panic. One rule to avoid them all.

Là où la plupart des erreurs de channels sont des blocages silencieux, fermer mal est bruyant : ça panique, immédiatement. Trois fautes y mènent — envoyer sur un channel fermé, fermer un channel déjà fermé, fermer un channel nil. Ce sont des panics ordinaires — un recover pourrait les attraper, mais ce serait masquer un bug de conception ; et le compilateur les laisse toutes passer. Mais une discipline unique les neutralise toutes les trois : un seul propriétaire ferme, du côté de l'émission, une seule fois.Where most channel errors are silent blocks, closing wrong is loud: it panics, immediately. Three faults lead there — sending on a closed channel, closing an already-closed channel, closing a nil channel. They're ordinary panics — a recover could catch them, but that would only mask a design bug; and the compiler waves them all through. But a single discipline neutralizes all three: one owner closes, on the sending side, exactly once.

Trois fautes que le compilateur laisse passerThree faults the compiler waves through
close(ch)
ch <- 1          // panic: send on closed channel
close(ch)        // panic: close of closed channel
var nope chan int
close(nope)      // panic: close of nil channel
// trois fautes, trois panics — toutes à l'exécution, et le programme meurt si personne ne les recover

Fermer fait une promesse irréversible : « plus aucune valeur ne viendra ». Tout ce qui la contredit panique. Envoyer après fermeture dément l'annonce ; fermer deux fois la répète sur un channel qui n'a plus d'état d'ouverture ; fermer nil n'a aucun sens. Contrairement à un blocage, ces fautes ne se cachent pas — elles arrêtent le programme net, ce qui est presque une bonne nouvelle : on les voit en test.Closing makes an irreversible promise: "no more values will come." Anything contradicting it panics. Sending after close denies the announcement; closing twice repeats it on a channel with no open-state left; closing nil is meaningless. Unlike a block, these faults don't hide — they stop the program cold, which is almost good news: you see them in testing.

Le type directionnel, ton garde-fouThe directional type, your guardrail

Une signature peut contraindre le sens d'un channel : chan<- int n'autorise que l'envoi (et la fermeture), <-chan int que la réception. Donner à une fonction un <-chan rend close impossible à la compilation — le récepteur ne peut plus se tromper. C'est l'un des rares endroits où Go transforme une convention en garantie de type. Là où tu peux exprimer l'asymétrie dans le type, fais-le : c'est une classe entière de panics qui disparaît du champ des possibles.A signature can constrain a channel's direction: chan<- int allows only sending (and closing), <-chan int only receiving. Handing a function a <-chan makes close a compile error — the receiver cannot get it wrong anymore. It's one of the rare places Go turns a convention into a type guarantee. Wherever you can express the asymmetry in the type, do: a whole class of panics drops out of the possible.

Le blocage te laisse une seconde chance. La fermeture fautive, non : elle panique, tout de suite.A block gives you a second chance. A bad close doesn't: it panics, right now.
№ 04Le piègeThe trap2 min

Plusieurs émetteurs, un seul channel : qui a le droit de fermer ?Many senders, one channel: who gets to close it?

La règle « l'émetteur ferme » se complique dès qu'il y a plusieurs émetteurs. Si chaque producteur ferme le channel partagé en finissant, le premier réveille les lecteurs — et le deuxième panique, sur un channel déjà fermé. Pire : un producteur encore en train d'envoyer après la première fermeture panique aussi. La fermeture n'appartient pas à un émetteur parmi d'autres ; elle appartient au moment où ils ont tous fini. Il faut donc un point de coordination unique.The rule 'the sender closes' gets tricky the moment there are several senders. If each producer closes the shared channel when it finishes, the first wakes the readers — and the second panics, on an already-closed channel. Worse: a producer still sending after that first close panics too. Closing belongs not to one sender among many; it belongs to the moment they've all finished. So you need a single point of coordination.

Plusieurs fermetures sur un channel partagéSeveral closes on a shared channel
// N producteurs écrivent dans le MÊME channel
for _, src := range sources {
    go func(src Source) {
        for v := range src {
            out <- v
        }
        close(out)     // CHACUN ferme out en finissant…
    }(src)
}
// le 1er close réveille les lecteurs ; le 2e PANIQUE (close of closed)
// et tout out <- v encore en vol panique aussi (send on closed)

Chaque producteur croit bien faire en fermant ce qu'il a alimenté. Mais out est partagé : la première fermeture est légitime, toutes les suivantes paniquent, et un envoi retardataire d'un autre producteur panique de son côté. « L'émetteur ferme » suppose un émetteur unique — dès qu'ils sont plusieurs, aucun ne possède le droit de fermer à lui seul.Each producer thinks it's doing right by closing what it fed. But out is shared: the first close is legitimate, every later one panics, and a straggler send from another producer panics on its side. "The sender closes" assumes a single sender — once there are several, none owns the right to close alone.

Signaler l'arrêt : ferme à côté, pas la donnéeSignalling stop: close beside, not the data

Pour dire à des producteurs « arrêtez d'envoyer », ne ferme jamais le channel de données : ferme un done séparé (ou annule un context). Sinon un producteur tentera d'envoyer sur un channel que tu viens de fermer — panic. La donnée et le signal vivent sur deux channels distincts : l'un que ferme l'émetteur quand il a fini, l'autre que ferme le consommateur quand il n'écoute plus.To tell producers "stop sending," never close the data channel: close a separate done (or cancel a context). Otherwise a producer will try to send on a channel you just closed — panic. Data and signal live on two distinct channels: one the sender closes when it's done, the other the consumer closes when it stops listening.

sync.Once, le dernier recours.sync.Once, the last resort.

Quand l'architecture rend vraiment impossible de désigner un fermeur unique, sync.Once garantit qu'un close ne s'exécute qu'une fois, quel que soit le nombre d'appelants : once.Do(func(){ close(ch) }). C'est utile, mais c'est un pansement — si tu en arrives là, c'est souvent que la propriété du channel est mal posée. La bonne question reste celle du numéro : qui possède ce channel, et donc qui a le droit de l'annoncer fini ?When the architecture genuinely makes it impossible to name a single closer, sync.Once guarantees a close runs only once, however many callers: once.Do(func(){ close(ch) }). It's useful, but it's a patch — if you reach for it, channel ownership is often misplaced. The right question stays the issue's: who owns this channel, and therefore who may announce it finished?

Fermer n'est pas « finir d'écrire ». C'est déclarer que plus personne n'écrira — ça ne se vote pas à plusieurs.Closing isn't "done writing." It's declaring no one will write again — that's not a group vote.
№ 05Bilan & éditoWrap-up & editorial2 min

Le dernier geste d'un channel : céder le droit d'y écrire.A channel's last gesture: relinquishing the right to write to it.

close paraît anodin — une fonction d'une ligne — mais c'est la seule opération des channels qui parle à tout le monde à la fois, et la seule qui panique quand on l'emploie de travers. Quatre points la tiennent : fermer diffuse une fin, on la détecte par range ou par le ok, seul l'émetteur ferme une fois, et à plusieurs émetteurs il faut un coordinateur. Au fond, fermer n'est pas détruire : c'est annoncer qu'on n'est plus propriétaire de l'envoi.close looks trivial — a one-line function — but it's the only channel operation that speaks to everyone at once, and the only one that panics when misused. Four points hold it: closing broadcasts an end, you detect it via range or the ok, only the sender closes once, and with several senders you need a coordinator. At bottom, closing isn't destroying: it's announcing you no longer own the sending.

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
La diffusionThe broadcastUn close réveille tous les <-ch d'un coup.One close wakes every <-ch at once.Tu signales N à la main : il faut connaître N, et compter juste.You signal N by hand: you must know N, and count right.
Détecter la finDetect the endrange sort à la fermeture ; v, ok donne ok=false.range exits on close; v, ok gives ok=false.Sans le ok, tu lis la valeur nulle à l'infini comme une donnée.Without the ok, you read the zero value forever as data.
L'émetteur fermeThe sender closesDu côté envoi, une seule fois. Exprime-le en chan<-.On the sending side, exactly once. Express it as chan<-.Send-on-closed, double close ou close nil : panic à l'exécution.Send-on-closed, double close or close nil: a runtime panic.
Plusieurs émetteursSeveral sendersWaitGroup puis un close ; arrêt via done, pas la donnée.WaitGroup then one close; stop via done, not the data.Chacun ferme le channel partagé : le second close panique.Each closes the shared channel: the second close panics.
Tout le volume 2 posait une question : qui possède cette valeur ? close y répond une dernière fois — « plus moi ».All of Volume 2 asked one question: who owns this value? close answers it one last time — "not me anymore."
Mot de l'éditeurFrom the editor

Trois numéros, une seule idée : la concurrence en Go est une affaire de propriété.Three issues, one idea: concurrency in Go is a matter of ownership.

Le volume 2 ressemblait à un cours sur les channels — envoyer, choisir, fermer. Mais relis-le : à chaque numéro, la vraie question n'était pas mécanique, elle était de propriété. Le channel transmettait la possession d'une valeur d'une goroutine à l'autre. select arbitrait qui, parmi plusieurs voix, obtenait la main. Et close, ce dernier geste, n'est rien d'autre que l'émetteur déclarant qu'il abandonne son droit d'écrire. Le verrou, lui, ne pose jamais cette question : il régule l'accès à une mémoire qui reste à tout le monde. Go te pousse ailleurs — vers un monde où, à chaque instant, une valeur a un propriétaire unique, et où communiquer, c'est transférer ce titre. C'est plus simple à raisonner, et c'est pour ça que ça tient à l'échelle.Volume 2 looked like a course on channels — send, choose, close. But reread it: in every issue, the real question wasn't mechanical, it was ownership. The channel handed a value's possession from one goroutine to another. select arbitrated which, among several voices, got the floor. And close, that final gesture, is nothing but the sender declaring it gives up its right to write. The lock never asks this question: it regulates access to memory that stays everyone's. Go pushes you elsewhere — toward a world where, at every instant, a value has a single owner, and where to communicate is to transfer that title. It's simpler to reason about, and that's why it holds at scale.

On quitte ici la concurrence. Le volume 3 ouvre un tout autre chantier : le système de types, et d'abord l'interface. En Go, un type satisfait une interface sans jamais le déclarer — il suffit qu'il en ait les méthodes. L'abstraction n'appartient pas à celui qui fournit le type, mais à celui qui le consomme. Étrange au premier abord, et pourtant c'est la même philosophie qu'ici, déplacée d'un cran : ce n'est pas le producteur qui impose la forme, c'est l'usage qui la révèle. D'où la maxime qu'on va dépiauter : accepte des interfaces, retourne des structs.We leave concurrency here. Volume 3 opens an entirely different site: the type system, and first the interface. In Go, a type satisfies an interface without ever declaring it — having the methods is enough. The abstraction belongs not to whoever provides the type, but to whoever consumes it. Strange at first, yet it's the same philosophy as here, shifted one notch: it isn't the producer who imposes the shape, it's the use that reveals it. Hence the maxim we'll take apart: accept interfaces, return structs.