Le channel, une valeur qui change de main The channel, a value changing hands

Un channel n'est pas une file d'attente : c'est un point de rendez-vous où la propriété d'une donnée passe d'une goroutine à l'autre. Bufferisé ou non, c'est la même idée — envoyer plutôt que partager derrière un verrou. Le cœur du slogan : partage la mémoire en communiquant. A channel isn't a queue: it's a rendezvous where a value's ownership passes from one goroutine to another. Buffered or not, same idea — send rather than share behind a lock. The heart of the slogan: share memory by communicating.

Audience
Dev qui a fait passer des données dans un channel sans se demander à qui elles appartenaient Dev who has pushed data through a channel without asking who owned it
ChapitresChapters
5
LectureReading
≈ 18 min
NiveauLevel
●●○○
Date
Sep 2026 Sep 2026

ChannelsCommunication

SommaireContents ·
№ 01CadrageFraming3 min

Un channel n'est pas une file d'attente. C'est un passage de main.A channel isn't a queue. It's a handoff.

Le volume 1 lançait des goroutines et les rejoignait ; la donnée, elle, ne faisait que transiter sans qu'on l'interroge. On ouvre le volume 2 sur ce transit lui-même. La plupart des langages synchronisent en protégeant une mémoire partagée derrière un verrou. Go propose l'inverse : au lieu de garder la valeur et d'en réguler l'accès, on la transmet — et celui qui la reçoit en devient seul propriétaire. C'est tout le slogan : ne communique pas en partageant la mémoire, partage la mémoire en communiquant.Volume 1 launched goroutines and rejoined them; the data merely passed through, unquestioned. Volume 2 opens on that passage itself. Most languages synchronize by guarding shared memory behind a lock. Go proposes the opposite: instead of keeping the value and regulating access to it, you hand it over — and whoever receives it becomes its sole owner. That's the whole slogan: don't communicate by sharing memory; share memory by communicating.

Partager la mémoire — et la défendreSharing memory — and defending it
var mu sync.Mutex
var total int

func add(n int) {
    mu.Lock()              // tout le monde touche la MÊME case
    total += n             // … à condition de bien prendre le verrou
    mu.Unlock()            // un oubli, et c'est la data race
}
Communiquer la valeur — et la lâcherCommunicating the value — and letting go
var results = make(chan int)

func worker(n int) {
    results <- n*n         // je calcule chez moi, puis je TRANSMETS
}                          // personne d'autre ne touche ma valeur
Le témoin change de mainThe baton changes hands
goroutine Agoroutine A
propriétaireowner
⟶
ch <- v
goroutine Bgoroutine B
nouveau propriétairenew owner

Un envoi n'est pas une copie laissée dans une boîte : c'est un témoin de relais. À l'instant où B le reçoit, A n'a plus à y toucher — et n'y touche plus. La valeur n'est jamais à deux mains en même temps : voilà pourquoi il n'y a ni verrou, ni course.A send isn't a copy left in a box: it's a relay baton. The instant B receives it, A no longer has to touch it — and doesn't. The value is never in two hands at once: that's why there's no lock, and no race.

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

« Transmets la valeur, puis lâche-la. » Tout ce numéro tient dans cette discipline : ce qu'on envoie, on cesse d'y toucher. Le channel garantit le moment du passage ; c'est à toi de garantir qu'aucune main ne reste accrochée derrière."Hand the value over, then let go." This whole issue lives in that discipline: what you send, you stop touching. The channel guarantees the moment of the handoff; it's on you to guarantee no hand stays clutching behind.

Le slogan, et sa petite trahison.The slogan, and its small betrayal.

« Don't communicate by sharing memory; share memory by communicating » est le proverbe fondateur de la concurrence en Go. Mais il décrit une intention, pas une garantie : rien dans le compilateur ne t'empêche d'envoyer un pointeur et de continuer à écrire derrière. Le channel déplace la propriété par convention ; tenir cette convention reste ton travail. Tout le numéro mène à ce piège — chapitre 4.'Don't communicate by sharing memory; share memory by communicating' is Go's founding proverb of concurrency. But it states an intent, not a guarantee: nothing in the compiler stops you from sending a pointer and going on writing behind it. The channel moves ownership by convention; honoring that convention stays your job. The whole issue builds to that trap — chapter 4.

№ 02Le rendez-vousThe rendezvous5 min

Un envoi non bufferisé ne dépose rien. Il attend une main.An unbuffered send drops nothing. It waits for a hand.

L'image de la boîte aux lettres est trompeuse. Sur un channel non bufferisé, ch <- v ne « met pas v dans le channel » pour qu'on le récupère plus tard : il bloque jusqu'à ce qu'une autre goroutine soit prête à recevoir, à l'instant même. Envoi et réception sont les deux moitiés d'un seul geste, qui se produit en un point unique du temps. C'est un rendez-vous, pas un dépôt — et c'est précisément ce qui en fait un outil de synchronisation.The mailbox image misleads. On an unbuffered channel, ch <- v doesn't 'put v in the channel' to be picked up later: it blocks until another goroutine is ready to receive, at that very instant. Send and receive are two halves of a single gesture, happening at one point in time. It's a rendezvous, not a drop-off — and that's exactly what makes it a synchronization tool.

Croire qu'on peut déposer et continuerBelieving you can drop it and move on
ch := make(chan int)       // capacité 0

ch <- 42                   // « je dépose 42 dans la boîte »
fmt.Println("envoyé")      // … on n'arrive JAMAIS ici
v := <-ch                  // personne pour recevoir : deadlock
// fatal error: all goroutines are asleep - deadlock!

Si ch <- 42 était un dépôt, la ligne suivante s'exécuterait. Elle ne s'exécute pas : l'envoi bloque, faute de receveur, et comme c'est la seule goroutine, le runtime déclare le deadlock. Un channel non bufferisé n'a aucune place de stockage — pas même une. Personne en face, personne pour avancer.If ch <- 42 were a drop-off, the next line would run. It doesn't: the send blocks for lack of a receiver, and since it's the only goroutine, the runtime declares deadlock. An unbuffered channel has no storage slot — not even one. No one across, no one moves.

Pourquoi le rendez-vous est utileWhy the rendezvous is useful

Bloquer n'est pas un défaut, c'est la fonction. Quand A repart de son envoi, il sait que B a pris la valeur — pas qu'elle attend quelque part. Cette certitude est ce qui permet d'orchestrer sans verrou : le simple fait de communiquer ordonne le temps des deux goroutines. Un chan struct sans donnée sert d'ailleurs exactement à ça : signaler, et rien d'autre.Blocking isn't a flaw, it's the feature. When A returns from its send, it knows B took the value — not that it's waiting somewhere. That certainty is what lets you orchestrate without a lock: merely communicating orders the two goroutines in time. A chan struct carrying no data exists for exactly that: to signal, and nothing else.

Nil bloque pour toujours.Nil blocks forever.

Un channel non initialisé vaut nil, et tout envoi ou réception sur un channel nil bloque définitivement — sans erreur, sans panique. C'est le cousin direct de la fuite du numéro précédent : oublier le make(chan T) et l'envoi se gare à jamais. Le détail compte d'autant plus qu'on s'en servira au volume select : mettre un cas à nil le neutralise proprement, ce qui est parfois exactement ce qu'on veut.An uninitialized channel is nil, and any send or receive on a nil channel blocks permanently — no error, no panic. It's the direct cousin of last issue's leak: forget the make(chan T) and the send parks forever. The detail matters all the more because we'll use it under select: setting a case's channel to nil cleanly disables it, which is sometimes exactly what you want.

Le verrou dit « attends ton tour pour toucher ». Le channel dit « tiens, c'est à toi maintenant ».The lock says "wait your turn to touch it." The channel says "here, it's yours now."
№ 03Bufferisé ou nonBuffered or not5 min

La capacité ne change pas ce qu'est un channel. Elle change quand il bloque.Capacity doesn't change what a channel is. It changes when it blocks.

Le second argument de make ajoute des places. À zéro, on a le rendez-vous du chapitre précédent : envoi et réception doivent coïncider. À N, le channel devient une boîte à N cases : l'émetteur peut prendre N tours d'avance sur le récepteur avant de devoir l'attendre. La sémantique de propriété est identique — on transmet toujours une valeur ; seul le couplage temporel entre les deux bouts se desserre.The second argument to make adds slots. At zero, you get the previous chapter's rendezvous: send and receive must coincide. At N, the channel becomes an N-slot box: the sender can run N steps ahead of the receiver before having to wait. The ownership semantics are identical — you still hand a value over; only the temporal coupling between the two ends loosens.

Rien n'est jamais « dans » le channelNothing is ever 'in' the channel
ch := make(chan int)       // cap 0 : aucune place
// règle : l'envoi bloque jusqu'à une réception (et inversement)

go func() { ch <- 1 }()    // attend un receveur
go func() { ch <- 2 }()    // attend un receveur
fmt.Println(<-ch, <-ch)    // chaque lecture débloque UN envoi
// len(ch) == 0, cap(ch) == 0 — il n'y a jamais rien « dedans »

Avec une capacité nulle, len(ch) vaut toujours 0 : la valeur ne séjourne pas, elle traverse. Chaque envoi reste suspendu jusqu'à ce qu'une réception vienne le cueillir. C'est le couplage maximal : l'émetteur ne prend jamais d'avance. Parfait quand tu veux que les deux goroutines marchent au même pas.With zero capacity, len(ch) is always 0: the value doesn't reside, it crosses. Each send hangs until a receive comes to pluck it. It's maximal coupling: the sender never runs ahead. Ideal when you want both goroutines to walk in lockstep.

Le buffer ne répare pas un deadlockA buffer doesn't fix a deadlock

Le réflexe tentant, face à un blocage, est d'agrandir le buffer jusqu'à ce que « ça passe ». C'est presque toujours une erreur : un buffer ne supprime pas le déséquilibre entre ce qu'on envoie et ce qu'on lit, il en diffère la sanction. Si tu produis plus vite que tu ne consommes, un buffer fini finira plein, et le blocage reviendra — plus tard, plus loin, plus dur à diagnostiquer. La taille du buffer est un choix de débit, jamais un correctif de logique. Choisis-la pour une raison chiffrée, ou laisse-la à zéro.The tempting reflex, facing a block, is to grow the buffer until it "goes through." That's almost always wrong: a buffer doesn't remove the imbalance between what you send and what you read, it defers the reckoning. If you produce faster than you consume, a finite buffer eventually fills, and the block returns — later, further away, harder to diagnose. Buffer size is a throughput choice, never a logic fix. Pick it for a number you can name, or leave it at zero.

Non bufferisé, tu sais quand l'autre a reçu. Bufferisé, tu sais seulement que tu as envoyé.Unbuffered, you know when the other received. Buffered, you only know that you sent.
№ 04Le piègeThe trap3 min

Envoyer un pointeur, c'est partager à nouveau — sans le verrou.Sending a pointer is sharing again — minus the lock.

Le channel transfère la propriété par convention, pas par contrainte. Tant que tu envoies des valeurs, la copie scelle le transfert : ce que reçoit l'autre n'a plus aucun lien avec le tien. Mais envoie un pointeur, une slice, une map — et tu n'as transmis qu'une adresse. Les deux goroutines pointent désormais la même mémoire, et tu viens de réintroduire exactement ce que le slogan voulait t'épargner : un partage non protégé. Le compilateur, lui, n'y voit rien.The channel transfers ownership by convention, not by force. As long as you send values, the copy seals the transfer: what the other receives has no link left to yours. But send a pointer, a slice, a map — and all you handed over is an address. Both goroutines now point at the same memory, and you've reintroduced exactly what the slogan meant to spare you: unguarded sharing. The compiler sees none of it.

L'adresse part, la main reste accrochéeThe address leaves, the hand keeps clutching
job := &Job{Status: "pending"}
ch <- job                  // j'envoie l'ADRESSE, pas une copie

job.Status = "done"        // … et je continue d'écrire dessus
// en face : v := <-ch ; lit v.Status au même moment
// deux goroutines, un seul Job → DATA RACE
// go run -race : WARNING: DATA RACE on Job.Status

L'envoi a réussi, le slogan semble respecté — et pourtant A et B écrivent et lisent le même Job en même temps. Le channel n'a déplacé qu'un pointeur ; la donnée, elle, est restée partagée. C'est une data race que rien dans le type ne signale — seul go run -race la voit, à l'exécution, si le test a la chance de la déclencher.The send succeeded, the slogan looks honored — and yet A and B write and read the same Job at once. The channel moved only a pointer; the data stayed shared. It's a data race nothing in the type flags — only go run -race catches it, at runtime, if a test is lucky enough to trip it.

Ce qui se copie, ce qui ne se copie pasWhat copies, what doesn't

Un envoi copie toujours la valeur de surface — mais une slice, une map ou un channel sont des références : la copie partage le tableau sous-jacent. Envoyer une []byte puis la modifier, c'est le même piège qu'un pointeur, en plus discret. La règle de sûreté est uniforme : ce que tu transmets, considère-le comme parti pour de bon.A send always copies the surface value — but a slice, a map or a channel are references: the copy shares the underlying array. Sending a []byte then mutating it is the pointer trap, just quieter. The safety rule is uniform: whatever you hand over, treat it as gone for good.

-race, dans ta CI.-race, in your CI.

Le détecteur de courses de Go (go test -race) instrumente les accès mémoire et signale tout partage non synchronisé qu'il observe à l'exécution. Il ne prouve pas l'absence de course — il ne voit que les chemins effectivement empruntés — mais il attrape la quasi-totalité des pointeurs envoyés puis touchés. C'est le seul garde-fou réel ici : le système de types laisse passer le pointeur, et le slogan ne tient que par ta discipline.Go's race detector (go test -race) instruments memory accesses and flags any unsynchronized sharing it observes at runtime. It doesn't prove the absence of races — it only sees the paths actually taken — but it catches nearly every pointer sent then touched. It's the only real guardrail here: the type system waves the pointer through, and the slogan holds only by your discipline.

Le channel te promet un passage de main. Le pointeur te laisse mentir sur le fait d'avoir lâché.The channel promises you a handoff. The pointer lets you lie about having let go.
№ 05Bilan & éditoWrap-up & editorial2 min

Un seul geste — ch <- v — et toute une philosophie de la concurrence.One gesture — ch <- v — and a whole philosophy of concurrency.

Le channel paraît anodin : une flèche, une valeur, un destinataire. Mais derrière la flèche se cache un choix de modèle — transmettre plutôt que protéger. Quatre idées suffisent à le tenir : la propriété passe et ne revient pas, le non-bufferisé est un rendez-vous, le buffer ne fait que desserrer le temps, et le pointeur peut trahir le transfert. Le reste du volume découle de là.The channel looks trivial: an arrow, a value, a recipient. But behind the arrow hides a choice of model — hand over rather than guard. Four ideas hold it all: ownership passes and doesn't return, the unbuffered channel is a rendezvous, the buffer only loosens time, and the pointer can betray the transfer. The rest of the volume follows from here.

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
Le transfertThe transferCe que tu envoies, tu cesses d'y toucher.What you send, you stop touching.La main reste accrochée : tu partages encore, sans verrou.The hand keeps clutching: you're still sharing, lockless.
Le rendez-vousThe rendezvousNon bufferisé : l'envoi attend une réception, et synchronise.Unbuffered: the send waits for a receive, and synchronizes.Tu crois déposer dans une boîte vide : deadlock immédiat.You think you're dropping into an empty box: instant deadlock.
Le bufferThe bufferLa capacité règle le débit, pas la logique. Choisis un chiffre.Capacity tunes throughput, not logic. Pick it for a number.Agrandi « pour que ça passe » : le blocage revient plus loin.Grown 'to make it go through': the block returns further down.
Le pointeurThe pointerEnvoie la valeur ; un pointeur n'est sûr que si tu l'abandonnes.Send the value; a pointer is safe only if you abandon it.Slice, map, *T envoyés puis modifiés : data race que seul -race voit.Slice, map, *T sent then mutated: a race only -race catches.
Le WaitGroup demandait « ont-elles fini ? ». Le channel demande autre chose : « qui possède cette valeur, maintenant ? »The WaitGroup asked "are they done?". The channel asks something else: "who owns this value, now?"
Mot de l'éditeurFrom the editor

La vraie question n'est jamais « comment verrouiller ». C'est « qui possède ».The real question is never "how to lock." It's "who owns."

On enseigne souvent les channels comme une tuyauterie : un moyen commode de faire passer des données entre goroutines. C'est exact et insuffisant. Le channel n'est pas un tuyau, c'est un déplacement de propriété. Tant que tu raisonnes en « accès à une mémoire partagée », tu chercheras le bon verrou, le bon ordre de prise, la bonne granularité — et tu te tromperas une fois sur dix. Le jour où tu raisonnes en « qui détient cette valeur à cet instant », la plupart de ces questions s'évaporent : il n'y a plus de partage à protéger, seulement une propriété qui circule. Le slogan de Go n'est pas un truc de style. C'est un changement de la question qu'on se pose.Channels are often taught as plumbing: a handy way to move data between goroutines. True, and not enough. A channel isn't a pipe, it's a movement of ownership. As long as you reason in 'access to shared memory,' you'll hunt for the right lock, the right acquisition order, the right granularity — and you'll get it wrong one time in ten. The day you reason in 'who holds this value right now,' most of those questions evaporate: there's no sharing left to protect, only ownership in motion. Go's slogan isn't a stylistic flourish. It's a change in the question you ask.

Prochain numéro : select. Un channel se lit ou s'écrit, point — mais le vrai code écoute plusieurs voix à la fois : un résultat, un timeout, un signal d'annulation. select attend le premier channel prêt et n'en sert qu'un. Avec default, il refuse d'attendre ; avec time.After, il pose une échéance ; et vide, select{} bloque pour l'éternité. On apprend à écouter plusieurs rendez-vous sans en manquer aucun — ni s'y perdre.Next issue: select. A channel is read or written, full stop — but real code listens to several voices at once: a result, a timeout, a cancellation signal. select waits for the first ready channel and serves only one. With default it refuses to wait; with time.After it sets a deadline; and empty, select{} blocks for eternity. We learn to listen to many rendezvous without missing one — or getting lost among them.