La goroutine qui fuit The goroutine that leaks

Une goroutine bloquée sur un envoi que plus personne ne lit ne plante pas : elle reste, vivante et inutile, jusqu'à l'arrêt du process. La fuite la plus silencieuse de Go. On la voit, on la mesure, et on la ferme — par un channel de sortie ou un contexte. A goroutine blocked on a send nobody reads doesn't crash: it lingers, alive and useless, until the process dies. Go's quietest leak. We make it visible, measure it, and shut it down — with a done channel or a context.

Audience
Dev qui lance des goroutines et veut être sûr qu'elles reviennent toutes Dev who launches goroutines and wants to be sure they all come back
ChapitresChapters
5
LectureReading
≈ 17 min
NiveauLevel
●●○○
Date
Août 2026 Aug 2026

FuiteChannelsCycle de vie

SommaireContents ·
№ 01CadrageFraming3 min

Elle ne plante pas. Elle ne s'imprime nulle part. Elle reste.It doesn't crash. It logs nowhere. It stays.

Au numéro précédent, le WaitGroup nous rendait la main quand toutes les goroutines avaient fini. Mais que se passe-t-il pour celle qui ne finit jamais ? Une goroutine bloquée sur un envoi que plus personne ne lira ne lève aucune erreur, n'apparaît dans aucun log, et ne décrémente aucun compteur. Elle reste là, vivante et inutile, jusqu'à l'arrêt du process — en retenant au passage tout ce qu'elle référence. C'est la fuite la plus silencieuse de Go.Last issue, the WaitGroup handed control back once every goroutine had finished. But what about the one that never finishes? A goroutine blocked on a send nobody will ever read raises no error, shows up in no log, decrements no counter. It just lingers, alive and useless, until the process dies — holding on to everything it references along the way. It's Go's quietest leak.

Le « premier arrivé » qui en abandonne N − 1 derrière luiThe 'first one wins' that strands N − 1 behind it
func first(urls []string) string {
    ch := make(chan string)        // non bufferisé
    for _, u := range urls {
        go func(u string) {
            ch <- fetch(u)         // bloque jusqu'à ce qu'on LISE
        }(u)
    }
    return <-ch                    // on prend la 1re réponse… et on part
}                                  // les autres : bloquées sur l'envoi, à jamais
Le grand livre des goroutinesThe goroutine ledger
3
lancéeslaunched
⟶
un seul <-chone <-ch
1
rejointesrejoined
⟶
resteleft over
2
fuitesleaked

Une fuite n'est pas un crash : c'est un déséquilibre. Tu lances trois goroutines, tu en rejoins une, et les deux autres ne reviennent jamais. Le compte ne tombe pas à zéro — il s'arrête à deux, pour toute la durée du programme.A leak isn't a crash: it's an imbalance. You launch three goroutines, rejoin one, and the other two never come back. The count doesn't fall to zero — it stalls at two, for the life of the program.

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

« Toute goroutine doit avoir une sortie garantie. » Le go est facile à écrire ; le retour, lui, n'est promis par personne. Tout ce numéro consiste à voir une goroutine qui ne reviendra pas, à la mesurer, puis à lui donner la porte qui lui manque."Every goroutine must have a guaranteed exit." The go is easy to write; the return is promised by no one. This whole issue is about spotting a goroutine that won't come back, measuring it, then handing it the door it's missing.

Bloquée n'est pas plantée.Blocked isn't crashed.

Le runtime ne considère pas une goroutine bloquée comme une erreur : attendre sur un channel est un état parfaitement légal. Il n'y a erreur fatale (fatal error, pas un panic rattrapable) que si TOUTES les goroutines sont bloquées en même temps (« all goroutines are asleep — deadlock! »). Tant qu'une seule tourne — souvent main — les fuites restent invisibles, et s'accumulent.The runtime doesn't treat a blocked goroutine as an error: waiting on a channel is a perfectly legal state. It only dies with a fatal error (not a recoverable panic) if ALL goroutines are blocked at once ('all goroutines are asleep — deadlock!'). As long as one keeps running — usually main — the leaks stay invisible, and pile up.

№ 02La fuite classiqueThe classic leak5 min

Un envoi sans lecteur ne renvoie pas d'erreur. Il n'en renvoie aucune.A send with no reader doesn't return an error. It returns nothing at all.

Le patron « le premier qui répond gagne » est partout : on lance N requêtes, on garde la plus rapide, on jette le reste. Sauf qu'en Go, « jeter » une goroutine ne la termine pas. Sur un channel non bufferisé, un envoi ne rend la main qu'au moment précis où quelqu'un lit. Si personne ne lira plus jamais, l'envoi ne revient jamais — et la goroutine reste parquée dessus, indéfiniment.The 'first responder wins' pattern is everywhere: fire N requests, keep the fastest, drop the rest. Except in Go, 'dropping' a goroutine doesn't end it. On an unbuffered channel, a send only returns at the exact moment someone reads. If no one ever will, the send never returns — and the goroutine stays parked on it, indefinitely.

L'envoi attend un lecteur qui ne reviendra pasThe send waits on a reader that won't return
func first(urls []string) string {
    ch := make(chan string)        // capacité 0
    for _, u := range urls {
        go func(u string) {
            ch <- fetch(u)         // 1 réussit, les autres se garent ici
        }(u)
    }
    return <-ch                    // une lecture, une seule
}
// N − 1 goroutines bloquées sur l'envoi : ni GC, ni timeout, ni log

Le return <-ch consomme un envoi. Les N − 1 autres goroutines atteignent leur ch <- fetch(u) et s'y arrêtent, en attente d'un récepteur qui n'existe plus. Elles ne sont pas mortes : elles sont parquées, et tout ce qu'elles tiennent — la réponse HTTP, le buffer, la closure — reste vivant avec elles. Un appel par seconde, et c'est au moins 86 400 goroutines fantômes par jour — N − 1 à chaque appel.The return <-ch consumes one send. The other N − 1 goroutines reach their ch <- fetch(u) and stop there, waiting on a receiver that no longer exists. They aren't dead: they're parked, and everything they hold — the HTTP response, the buffer, the closure — stays alive with them. One call a second, and that's at least 86,400 ghost goroutines a day — N − 1 per call.

Le symétrique : la réception orphelineThe mirror image: the orphaned receive

La fuite n'a rien de propre à l'envoi. Une goroutine bloquée sur <-ch en attente d'une valeur qui ne viendra jamais — parce que le producteur est sorti sans fermer le channel — fuit exactement de la même façon. Tout blocage sans réveil possible est une fuite : envoi sans lecteur, réception sans producteur, select sans cas joignable.The leak isn't unique to sends. A goroutine blocked on <-ch waiting for a value that never comes — because the producer left without closing the channel — leaks in exactly the same way. Any block with no possible wake-up is a leak: send with no reader, receive with no producer, a select with no reachable case.

Le GC ne ramasse pas une goroutine.The GC doesn't collect a goroutine.

On croit souvent qu'une goroutine « dont personne ne tient la référence » sera nettoyée. Faux : le ramasse-miettes collecte la mémoire inatteignable, pas les goroutines parquées. Une goroutine bloquée est une racine vivante pour le runtime — elle et toute sa pile restent, qu'on ait gardé un handle dessus ou non. La seule façon de la libérer, c'est de la débloquer.People often assume a goroutine 'no one holds a reference to' will be cleaned up. Wrong: the garbage collector reclaims unreachable memory, not parked goroutines. A blocked goroutine is a live root for the runtime — it and its whole stack stay, whether or not you kept a handle on it. The only way to free it is to unblock it.

Lancer une goroutine, c'est ouvrir une parenthèse. Une fuite, c'est une parenthèse qu'on ne referme jamais.Launching a goroutine opens a parenthesis. A leak is a parenthesis you never close.
№ 03Rendre la fuite visibleMaking the leak visible4 min

On ne corrige pas ce qu'on ne voit pas. Compte les goroutines.You can't fix what you can't see. Count the goroutines.

Une fuite ne lève rien, donc elle ne se trouve pas par hasard : elle se mesure. Et le bon signe vital tient en un appel — runtime.NumGoroutine(). En régime stable, ce nombre oscille autour d'une valeur ; s'il monte tout droit sous charge constante, tu fuis. En test, on automatise le verdict avec goleak. Et en production, le profil pprof te dit exactement sur quelle ligne tes fantômes sont parqués.A leak raises nothing, so you won't find it by luck: you measure it. And the right vital sign is one call away — runtime.NumGoroutine(). In steady state that number hovers around a value; if it climbs in a straight line under constant load, you're leaking. In tests, goleak automates the verdict. And in production, the pprof profile tells you exactly which line your ghosts are parked on.

Le compteur qui monte et ne redescend pasThe counter that rises and never falls
before := runtime.NumGoroutine()
for i := 0; i < 1000; i++ {
    first(urls)                    // chaque appel abandonne N − 1 goroutines
}
runtime.GC()                       // ne change rien : elles ne sont pas collectables
fmt.Println(runtime.NumGoroutine() - before)
// → 2000, et le nombre ne redescend jamais

Mille appels, deux mille goroutines en plus — et un runtime.GC() qui n'en récupère aucune, la preuve qu'elles sont bloquées et non simplement en attente de nettoyage. C'est grossier, mais imparable : un nombre de goroutines proportionnel au trafic cumulé, jamais au trafic instantané, est la signature d'une fuite. Le même nombre exposé en métrique (/metrics) transforme ce diagnostic en alerte.A thousand calls, two thousand extra goroutines — and a runtime.GC() that reclaims none of them, proof they're blocked rather than awaiting cleanup. It's crude but decisive: a goroutine count that tracks cumulative traffic, never instantaneous traffic, is the signature of a leak. The same number exported as a metric (/metrics) turns this diagnosis into an alert.

En production : pprofIn production: pprof

Importe net/http/pprof, puis ouvre go tool pprof http://localhost:6060/debug/pprof/goroutine : tu obtiens, regroupées par pile, toutes les goroutines vivantes et leur nombre. Mille lignes identiques bloquées sur chan send dans first, et le coupable se désigne lui-même. La fuite était invisible ; elle ne l'est plus. Le profil ne ment pas : il liste ce que le runtime tient réellement en vie, ligne par ligne.Import net/http/pprof, then open go tool pprof http://localhost:6060/debug/pprof/goroutine: you get every live goroutine grouped by stack, with counts. A thousand identical frames blocked on chan send in first, and the culprit names itself. The leak was invisible; it isn't anymore. The profile doesn't lie: it lists what the runtime is actually keeping alive, line by line.

Un crash crie son adresse. Une fuite, il faut aller la compter là où elle dort.A crash shouts its address. A leak, you have to go count where it sleeps.
№ 04Fermer la fuiteClosing the leak4 min

La fuite ne se ferme pas côté lecteur. Elle se ferme côté sortie.You don't close the leak at the reader. You close it at the exit.

Le réflexe est de vouloir « lire le reste » — vider le channel pour libérer les bloquées. Mais ça ne change rien au fond : tu cours toujours après autant de lectures qu'il y a eu d'envois. Le vrai correctif est ailleurs : donner à chaque envoi une seconde issue. Soit on livre la valeur, soit on reçoit l'ordre de partir. C'est le rôle du select couplé à un signal d'annulation — le context.The instinct is to 'read the rest' — drain the channel to free the blocked senders. But that fixes nothing: you're still chasing as many reads as there were sends. The real fix is elsewhere: give every send a second way out. Either it delivers the value, or it receives the order to leave. That's the job of select paired with a cancellation signal — the context.

Chaque envoi a deux issues : livrer, ou abandonnerEvery send has two exits: deliver, or give up
func first(ctx context.Context, urls []string) string {
    ctx, cancel := context.WithCancel(ctx)
    defer cancel()                 // au return : signale à toutes de partir
    ch := make(chan string)
    for _, u := range urls {
        go func(u string) {
            select {
            case ch <- fetch(u):   // soit on livre…
            case <-ctx.Done():     // …soit on abandonne et on sort
            }
        }(u)
    }
    return <-ch                    // le defer cancel() débloque les N − 1

Le select met l'envoi et <-ctx.Done() en concurrence : la goroutine sort par celui qui se présente le premier. Quand first retourne, le defer cancel() ferme ctx.Done() — les N − 1 goroutines encore en attente prennent aussitôt cette branche et terminent. Le canal d'annulation est la porte de sortie qui manquait. C'est le patron à connaître par cœur pour tout fan-out.The select races the send against <-ctx.Done(): the goroutine leaves by whichever fires first. When first returns, the defer cancel() closes ctx.Done() — the N − 1 goroutines still waiting immediately take that branch and finish. The cancellation channel is the missing exit door. This is the pattern to know by heart for any fan-out.

Le réflexe qui généraliseThe reflex that generalizes

Au moment où tu écris go, pose-toi une seule question : par où cette goroutine sort-elle, dans le pire des cas ? Si la seule réponse est « quand quelqu'un lira », tu viens d'écrire une fuite potentielle. Donne-lui une seconde réponse — un ctx.Done(), un channel done, un buffer — et la fuite n'a plus où se loger.The moment you write go, ask one question: how does this goroutine exit, in the worst case? If the only answer is "when someone reads," you've just written a potential leak. Give it a second answer — a ctx.Done(), a done channel, a buffer — and the leak has nowhere left to live.

defer cancel(), toujours.defer cancel(), always.

context.WithCancel rend deux choses : un contexte et une fonction cancel. Ne pas l'appeler est lui-même une fuite — celle du contexte, qui retient ses ressources jusqu'à expiration du parent. Le defer cancel() juste après la création est non négociable : il garantit l'annulation sur tous les chemins de retour, exactement comme le defer Done() du numéro précédent garantissait le décrément. Même discipline, autre compteur.context.WithCancel returns two things: a context and a cancel function. Not calling it is itself a leak — of the context, which holds its resources until the parent expires. The defer cancel() right after creation is non-negotiable: it guarantees cancellation on every return path, exactly as last issue's defer Done() guaranteed the decrement. Same discipline, different counter.

Tu n'as pas à lire tout ce que tes goroutines envoient. Tu dois seulement leur laisser une porte quand tu cesses d'écouter.You don't have to read everything your goroutines send. You only have to leave them a door when you stop listening.
№ 05Bilan & éditoWrap-up & editorial2 min

Le go est gratuit. Le retour, c'est toi qui le garantis.The go is free. The return is on you to guarantee.

Une fuite de goroutine n'est jamais un bug d'API : c'est une promesse de retour qu'on a oublié de tenir. Le runtime ne te préviendra pas, le GC ne nettoiera pas, le compilateur laissera passer. Quatre réflexes suffisent à les fermer toutes — et tous tiennent dans une seule question, posée au moment du go : par où cette goroutine sort-elle ?A goroutine leak is never an API bug: it's a promise of return you forgot to keep. The runtime won't warn you, the GC won't clean up, the compiler will wave it through. Four reflexes are enough to close them all — and they all reduce to one question, asked at the moment of go: how does this goroutine exit?

Le réflexeThe reflexLa règleThe ruleSi tu la ratesIf you miss it
Une sortieAn exitAu moment du go, sache par où la goroutine termine.At the go, know where the goroutine ends.Sans issue, elle se gare sur un blocage et reste jusqu'à l'arrêt du process.With no exit, it parks on a block and stays until the process dies.
L'envoi sous selectSend under selectUn envoi qui peut bloquer va sous select, avec <-ctx.Done().A send that can block goes under select, with <-ctx.Done().Envoi nu sur channel : dès que le lecteur part, la goroutine fuit.A bare channel send: the moment the reader leaves, the goroutine leaks.
defer cancel()Juste après WithCancel — l'annulation part sur tous les retours.Right after WithCancel — cancellation fires on every return.Oublié : le contexte fuit, et le signal de sortie n'arrive jamais.Forgotten: the context leaks, and the exit signal never arrives.
Mesure, ne devine pasMeasure, don't guessruntime.NumGoroutine, goleak en test, pprof en prod.runtime.NumGoroutine, goleak in tests, pprof in prod.Sans mesure, la fuite grandit en silence jusqu'à l'OOM.Unmeasured, the leak grows silently until the OOM.
Le WaitGroup comptait celles qui finissent. Celle-ci ne finit pas — et c'est pour ça qu'aucun compteur ne la voyait.The WaitGroup counted the ones that finish. This one doesn't — which is why no counter ever saw it.
Mot de l'éditeurFrom the editor

Une goroutine n'est pas un appel. C'est une promesse de retour.A goroutine isn't a call. It's a promise of return.

Depuis trois numéros, ce volume répète la même chose sous trois angles : Go te donne un mécanisme d'une simplicité désarmante — go, wg.Add, ch <- v — et te confie l'invariant qu'il refuse de vérifier. Le WaitGroup ne vérifiait pas où tu posais ton Add ; le channel ne vérifie pas qu'il y aura un lecteur. La fuite est le prix de cette confiance : le langage te laisse lancer une goroutine sans jamais te demander comment elle reviendra. Personne ne te le demandera — ni le compilateur, ni le runtime, ni le GC. C'est exactement la liberté que tu voulais, et exactement la responsabilité qui vient avec.Three issues in, this volume keeps saying the same thing from three angles: Go hands you a disarmingly simple mechanism — go, wg.Add, ch <- v — and entrusts you with the invariant it refuses to check. The WaitGroup didn't check where you put your Add; the channel doesn't check that there'll be a reader. The leak is the price of that trust: the language lets you launch a goroutine without ever asking how it comes back. No one will ask — not the compiler, not the runtime, not the GC. It's exactly the freedom you wanted, and exactly the responsibility that comes with it.

Le volume 1 s'achève ici : on a lancé une goroutine, attendu N, et fermé celle qui fuyait. À chaque fois, la donnée ne faisait que circuler dans un channel sans qu'on l'interroge vraiment. Le volume 2 retourne le projecteur sur ce channel lui-même. Pas une file d'attente : un point de rendez-vous où la propriété d'une valeur passe d'une main à l'autre. Bufferisé ou non, fermé ou ouvert, à l'écoute dans un select — c'est le cœur du slogan de Go : partage la mémoire en communiquant. On commence par le commencement : une valeur qui change de main.Volume 1 ends here: we launched a goroutine, waited on N, and closed the one that leaked. Each time, the data merely flowed through a channel without our really questioning it. Volume 2 turns the spotlight on that channel itself. Not a queue: a rendezvous where a value's ownership passes from one hand to another. Buffered or not, closed or open, listened to inside a select — it's the heart of Go's slogan: share memory by communicating. We start at the start: a value changing hands.