La copie qui casse The copy that breaks

Copier une struct qui contient un sync.Mutex, c'est copier un verrou à moitié pris — et go vet te l'interdit pour de bonnes raisons. WaitGroup, slices partagées : certains types ne survivent pas à une copie. La règle copylocks, et pourquoi. Copying a struct that holds a sync.Mutex copies a half-held lock — and go vet forbids it for good reason. WaitGroup, shared slices: some types don't survive a copy. The copylocks rule, and why.

Audience
Dev dont le mutex ne protège rien ou dont la WaitGroup bloque, sans comprendre que c'est une copie Dev whose mutex protects nothing or whose WaitGroup blocks, not realizing it's a copy
ChapitresChapters
5
LectureReading
≈ 15 min
NiveauLevel
●●●○
Date
Nov 2027 Nov 2027

CopieMutexgo vet

SommaireContents ·
№ 01CadrageFraming3 min

Tout est copié — sauf ce qui ne survit pas à la copie. Un verrou dupliqué ne protège plus rien.Everything is copied — except what doesn't survive the copy. A duplicated lock protects nothing anymore.

Tout ce volume a célébré la copie : elle isole, elle protège, elle rend une fonction incapable de muter ton original sans le demander. Mais il existe une famille de types pour lesquels copier n'est pas un service neutre — c'est une faute. Ce sont les types qui portent un état d'identité, un état dont l'intérêt même est qu'il n'existe qu'en un seul exemplaire. Le cas archétypal est le verrou. Un sync.Mutex n'est pas une donnée inerte qu'on peut dupliquer : c'est un petit automate qui mémorise s'il est pris ou libre, et qui tient la file des goroutines en attente. Sa raison d'être est de coordonner plusieurs accès à travers un point unique. Le copier, c'est créer un second verrou, indépendant du premier, qui ignore tout de ce que l'original protège — et si on le copie pendant qu'il est pris, on fabrique un verrou figé dans un état incohérent. Deux verrous là où il en fallait un, c'est zéro exclusion mutuelle. Le langage connaît ce danger et l'a outillé : go vet embarque une analyse, copylocks, dont l'unique métier est de détecter qu'un type contenant un verrou est passé ou copié par valeur, et de te prévenir. C'est la contre-indication formelle de la sémantique de valeur — la seule zone où « tout est copié » devient « ceci, surtout pas ».This whole volume celebrated the copy: it isolates, it protects, it makes a function unable to mutate your original without asking. But there's a family of types for which copying isn't a neutral service — it's a fault. These are the types carrying an identity state, a state whose whole point is that it exists in a single instance. The archetypal case is the lock. A sync.Mutex isn't inert data you can duplicate: it's a small automaton remembering whether it's held or free, and keeping the queue of waiting goroutines. Its reason for being is to coordinate several accesses through a single point. Copying it is creating a second lock, independent of the first, ignorant of everything the original protects — and if you copy it while it's held, you fabricate a lock frozen in an inconsistent state. Two locks where one was needed is zero mutual exclusion. The language knows this danger and has tooled it: go vet ships an analysis, copylocks, whose sole job is to detect that a type containing a lock is passed or copied by value, and to warn you. It's the formal contraindication of value semantics — the one zone where 'everything is copied' becomes 'this, above all, not.'

Un verrou copié par mégarde, et go vet qui le voitA lock accidentally copied, and go vet that sees it
type Safe struct {
    mu    sync.Mutex     // un verrou : tient un état (pris / libre + file)
    count int
}

func (s Safe) Inc() {    // receveur VALEUR → s est une COPIE de la struct…
    s.mu.Lock()          // … donc on verrouille le mutex de la copie, pas l'original
    s.count++
    s.mu.Unlock()
}
// $ go vet
// Inc passes lock by value: Safe contains sync.Mutex
Deux familles de typesTwo families of types
se copie librement
int, string, struct de données, time.Time — une copie vaut l'original
|
ne se copie pas
sync.Mutex, RWMutex, WaitGroup, Once, atomic.* — et tout ce qui les contient

La frontière est claire : un type est non-copiable dès qu'il tient un état que la copie dédoublerait — un verrou, un compteur de synchronisation, une garantie d'unicité. Dès qu'une struct embarque l'un d'eux, elle hérite de l'interdiction. Et go vet la fait respecter.The boundary is clear: a type is non-copyable as soon as it holds a state the copy would split — a lock, a synchronization counter, a uniqueness guarantee. The moment a struct embeds one of them, it inherits the ban. And go vet enforces it.

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

« Ce type contient-il un verrou ? alors il ne circule que par pointeur, jamais par valeur. » C'est le corollaire dur de tout le volume. Le numéro 2 a montré qu'on choisit souvent le receveur pointeur ; ici, on n'a plus le choix. Un type à verrou impose des receveurs pointeur, un passage par *T, et une vigilance sur chaque endroit — affectation, range, retour de fonction — où une copie pourrait se glisser. go vet est l'ami qui les repère pour toi."Does this type contain a lock? then it travels only by pointer, never by value." It's the hard corollary of the whole volume. Issue 2 showed we often choose the pointer receiver; here, we no longer have the choice. A lock type imposes pointer receivers, a pass by *T, and vigilance at every spot — assignment, range, function return — where a copy could slip in. go vet is the friend that spots them for you.

Pourquoi un verrou est un état, pas une donnéeWhy a lock is a state, not data

Une donnée décrit quelque chose : un nombre, un nom, une date. La copier produit une seconde description, tout aussi valable. Un verrou ne décrit rien — il coordonne. Son contenu, c'est la trace vivante d'un accord entre goroutines : qui le détient à cet instant, qui patiente. Cette trace n'a de sens qu'au singulier, en un point partagé que tout le monde regarde. La dupliquer, c'est comme photocopier le bâton de parole d'une assemblée : on se retrouve avec deux bâtons, et plus personne ne sait qui a la parole. C'est pourquoi ces types embarquent souvent un marqueur interne « ne pas copier » que go vet sait lire : le langage encode, dans le type lui-même, qu'il appartient à la famille des identités, pas à celle des valeurs.Data describes something: a number, a name, a date. Copying it produces a second, equally valid description. A lock describes nothing — it coordinates. Its content is the living trace of an agreement between goroutines: who holds it at this instant, who waits. That trace only makes sense in the singular, at a shared point everyone watches. Duplicating it is like photocopying an assembly's talking stick: you end up with two sticks, and no one knows who has the floor. That's why these types often embed an internal 'do not copy' marker that go vet can read: the language encodes, in the type itself, that it belongs to the family of identities, not that of values.

№ 02La surpriseThe surprise4 min

Un receveur valeur sur un type à mutex verrouille une copie. Chaque goroutine ferme une porte… différente.A value receiver on a mutex type locks a copy. Each goroutine shuts a door… a different one.

Reprenons le compteur du numéro 2, mais protégé cette fois par un mutex, comme on le ferait pour un accès concurrent. Si la méthode Inc a un receveur valeur, deux désastres se superposent. Le premier, on le connaît : c est une copie, donc c.n++ incrémente une copie jetable, et le compteur ne monte jamais. Le second est plus grave, car il touche à la sûreté : c.mu est lui aussi une copie du mutex. Chaque appel de Inc verrouille et déverrouille son propre mutex local, né et mort avec l'appel. Mille goroutines qui appellent Inc ferment chacune une porte différente — il n'y a aucune exclusion mutuelle, parce qu'il n'y a aucun verrou commun à se disputer. Le mutex est là, le code l'utilise correctement en apparence, et pourtant il ne protège rien du tout. C'est exactement le genre de bug que la sémantique de valeur rend possible : tout fonctionne « comme prévu » — chaque copie verrouille bien son mutex — sauf que le « comme prévu » est faux. Et c'est précisément pour ça que go vet existe : il détecte statiquement, sans même exécuter le programme, qu'un type contenant un verrou voyage par valeur, et te le signale d'un message net — passes lock by value. La parade est celle, désormais familière, du receveur pointeur : un seul mutex, partagé, réellement verrouillé. Mais ici le pointeur n'est plus une optimisation ni un confort : c'est la condition de correction du programme.Take the counter from issue 2, but protected this time by a mutex, as you would for concurrent access. If the Inc method has a value receiver, two disasters stack. The first, we know: c is a copy, so c.n++ increments a throwaway copy, and the counter never rises. The second is graver, because it touches safety: c.mu is also a copy of the mutex. Each call to Inc locks and unlocks its own local mutex, born and dead with the call. A thousand goroutines calling Inc each shut a different door — there's no mutual exclusion, because there's no common lock to contend for. The mutex is there, the code uses it correctly in appearance, and yet it protects nothing at all. It's exactly the kind of bug value semantics makes possible: everything works 'as expected' — each copy duly locks its mutex — except 'as expected' is wrong. And that's precisely why go vet exists: it detects statically, without even running the program, that a type containing a lock travels by value, and flags it with a clean message — passes lock by value. The fix is the now-familiar pointer receiver: a single, shared, truly locked mutex. But here the pointer is no longer an optimization or a convenience: it's the program's correctness condition.

Receveur valeur : mille mutex locaux, zéro protectionValue receiver: a thousand local mutexes, zero protection
type Counter struct {
    mu sync.Mutex
    n  int
}

func (c Counter) Inc() {   // receveur VALEUR : c est une COPIE de la struct
    c.mu.Lock()            // … on verrouille le mutex de la copie
    c.n++                  // … on incrémente la copie (perdu, cf. n° 2)
    c.mu.Unlock()
}
// 1000 goroutines appellent c.Inc() :
//   • chacune verrouille un mutex DIFFÉRENT → aucune exclusion mutuelle
//   • c.n final = 0 : tous les incréments meurent avec leur copie
// $ go vet → Inc passes lock by value: Counter contains sync.Mutex

Le code a l'air thread-safe : il y a un mutex, on le verrouille, on le déverrouille. C'est l'illusion parfaite. Mais chaque goroutine verrouille un exemplaire à elle, donc aucune n'attend aucune autre. Sans go vet, ce bug ne se révèle qu'en production, sous forme de corruption de données intermittente — le pire des symptômes. Avec go vet, il est attrapé avant le premier déploiement. C'est l'argument massue pour câbler go vet dans ton intégration continue.The code looks thread-safe: there's a mutex, you lock it, you unlock it. It's the perfect illusion. But each goroutine locks its own instance, so none waits for any other. Without go vet, this bug only surfaces in production, as intermittent data corruption — the worst of symptoms. With go vet, it's caught before the first deploy. It's the knockout argument for wiring go vet into your CI.

Le seul piège du volume que l'outil attrape pour toiThe volume's only trap the tool catches for you

Les pièges des numéros 1 et 2 — mutation perdue, interface non satisfaite — sont silencieux : le compilateur les accepte, à toi de les voir. Celui-ci est différent, parce que le langage a jugé la copie d'un verrou assez dangereuse pour la traquer activement. go vet n'est pas un avertissement cosmétique : c'est le signe que tu es entré dans la zone rouge de la sémantique de valeur, celle où copier n'isole plus mais corrompt. Traite chaque « passes lock by value » comme une erreur, jamais comme un détail — il pointe presque toujours un bug de concurrence réel, juste pas encore déclenché.The traps of issues 1 and 2 — lost mutation, unsatisfied interface — are silent: the compiler accepts them, it's on you to see them. This one is different, because the language deemed copying a lock dangerous enough to actively hunt it. go vet isn't a cosmetic warning: it's the sign you've entered value semantics' red zone, the one where copying no longer isolates but corrupts. Treat every 'passes lock by value' as an error, never a detail — it almost always points at a real concurrency bug, just not yet triggered.

Un mutex copié verrouille dans le vide. Le code paraît sûr, et ne protège rien — sauf que go vet le voit avant toi.A copied mutex locks into the void. The code looks safe, and protects nothing — except go vet sees it before you.
№ 03La mécaniqueThe mechanics5 min

copylocks ne regarde pas si le verrou est pris. Il interdit la copie d'un type à verrou, point — statiquement.copylocks doesn't check whether the lock is held. It forbids copying a lock type, period — statically.

Pour comprendre pourquoi le langage est si catégorique, il faut regarder ce qu'un mutex contient vraiment. Réduit à l'essentiel, c'est un mot d'état — quelques bits qui disent si le verrou est pris et combien de goroutines font la queue — accompagné d'un sémaphore qui sert à endormir et réveiller ces goroutines. Copier un mutex, c'est dupliquer ce mot. Si la copie se fait pendant que le verrou est pris, la copie naît « verrouillée » : elle croit qu'une goroutine la détient, mais le déverrouillage de l'original ne la touchera jamais, et plus personne ne la libérera. Toute goroutine qui tentera de la prendre attendra indéfiniment. Voilà le scénario catastrophe. Mais go vet ne cherche pas à savoir si, à tel instant, le verrou est pris ou libre — il ne le peut pas, c'est une information d'exécution. Son analyse copylocks est purement statique et bien plus simple : elle repère tout type qui possède les méthodes Lock et Unlock — autrement dit qui satisfait sync.Locker — et signale chaque endroit où une valeur d'un tel type, ou d'une struct qui en contient un, est copiée : passée par valeur, retournée, rangée dans une variable, parcourue dans un range, ou reçue par un receveur valeur. La règle est volontairement grossière : pas de copie du tout, jamais, plutôt que des copies « seulement quand c'est sûr ». Et cette mécanique, tu peux la retourner à ton avantage : en embarquant dans ton propre type un champ minuscule qui implémente Lock et Unlock sans rien faire, tu déclares ton type non-copiable et tu obtiens la protection de copylocks gratuitement, sans le moindre coût à l'exécution.To understand why the language is so categorical, you have to look at what a mutex actually contains. Reduced to essentials, it's a state word — a few bits saying whether the lock is held and how many goroutines are queuing — together with a semaphore used to sleep and wake those goroutines. Copying a mutex duplicates that word. If the copy happens while the lock is held, the copy is born 'locked': it believes a goroutine holds it, but the original's unlock will never touch it, and no one will free it. Any goroutine trying to take it will wait forever. That's the catastrophe scenario. But go vet doesn't try to know whether, at a given instant, the lock is held or free — it can't, that's runtime information. Its copylocks analysis is purely static and far simpler: it spots any type with the Lock and Unlock methods — that is, satisfying sync.Locker — and flags every place where a value of such a type, or of a struct containing one, is copied: passed by value, returned, stored in a variable, ranged over, or received by a value receiver. The rule is deliberately coarse: no copy at all, ever, rather than copies 'only when safe.' And this mechanic, you can turn to your advantage: by embedding in your own type a tiny field that implements Lock and Unlock doing nothing, you declare your type non-copyable and get copylocks' protection for free, with no runtime cost whatsoever.

Ce qu'un mutex tient, et pourquoi le dupliquer le tueWhat a mutex holds, and why duplicating it kills it
// conceptuellement, un sync.Mutex tient un petit mot d'état :
type Mutex struct {
    state int32   // bits : verrouillé ? combien de goroutines en attente ?
    sema  uint32  // sémaphore qui réveille les goroutines en file
}

// copier ce mot pendant qu'il est PRIS produit un mutex « verrouillé »
// que plus personne ne déverrouillera : l'Unlock de l'original agit sur
// l'original, jamais sur la copie. Verrou mort, goroutines figées à jamais.

Le verrou n'est pas une serrure abstraite : c'est un état concret, partagé, que plusieurs goroutines lisent et modifient à un seul endroit. Le copier brise l'unicité dont dépend toute sa logique — il y a maintenant deux états là où la coordination en exigeait un. Que la copie soit faite verrou pris (deadlock) ou verrou libre (deux verrous indépendants, exclusion brisée), le résultat est faux. D'où le choix de go vet : ne pas distinguer les cas, interdire la copie en bloc.The lock isn't an abstract latch: it's a concrete, shared state several goroutines read and modify at a single place. Copying it breaks the uniqueness all its logic depends on — there are now two states where coordination required one. Whether the copy is made lock-held (deadlock) or lock-free (two independent locks, broken exclusion), the result is wrong. Hence go vet's choice: don't distinguish cases, forbid the copy outright.

Le verrou est un état partagé, pas une donnée. Le dupliquer brise l'unicité dont dépend toute coordination — alors le langage l'interdit en bloc.The lock is shared state, not data. Duplicating it breaks the uniqueness all coordination depends on — so the language bans it outright.
№ 04Le piègeThe trap4 min

Le mutex n'est que le premier d'une famille. WaitGroup copiée, Once copiée, slice de verrous parcourue : même faute.The mutex is only the first of a family. A copied WaitGroup, a copied Once, a ranged slice of locks: same fault.

Le mutex est le visage le plus connu du problème, mais la règle vaut pour toute une famille de types de synchronisation, qui portent le même marqueur non-copiable. Le piège le plus fréquent en pratique n'est d'ailleurs pas le mutex, c'est la WaitGroup passée par valeur à une goroutine. On écrit go worker(wg) sans réfléchir, worker reçoit une copie de la WaitGroup, son Done décrémente le compteur de la copie — pas celui de l'original — et le Wait du parent attend un compteur qui ne retombera jamais à zéro. Résultat : un blocage définitif, un de ces deadlocks qu'on met une heure à diagnostiquer si on ne pense pas à lancer go vet. La même mécanique frappe sync.Once (une copie ne partage pas l'état « déjà fait », donc l'action peut s'exécuter deux fois), les types atomic, et — piège discret — le parcours d'une slice de structs contenant un verrou : for _, s := range services copie chaque élément, verrou compris. La parade est unique et tient en une phrase : ces types ne se passent et ne se rangent que par pointeur. Leurs méthodes sont à receveur pointeur, on les met dans des structs qu'on manipule via *T, et quand on range une collection, on itère sur les indices. Le numéro entier converge vers cette discipline, et go vet est là pour la faire respecter à chaque fois que l'habitude de copier reprend le dessus.The mutex is the best-known face of the problem, but the rule holds for a whole family of synchronization types, which carry the same non-copyable marker. The most frequent trap in practice isn't even the mutex, it's the WaitGroup passed by value to a goroutine. You write go worker(wg) without thinking, worker receives a copy of the WaitGroup, its Done decrements the copy's counter — not the original's — and the parent's Wait waits for a counter that will never fall to zero. Result: a permanent block, one of those deadlocks that take an hour to diagnose if you don't think to run go vet. The same mechanic hits sync.Once (a copy doesn't share the 'already done' state, so the action can run twice), the atomic types, and — a discreet trap — ranging over a slice of structs containing a lock: for _, s := range services copies each element, lock included. The fix is unique and fits in one sentence: these types are passed and stored only by pointer. Their methods have pointer receivers, you put them in structs handled via *T, and when you range a collection, you iterate over the indices. The whole issue converges on this discipline, and go vet is there to enforce it every time the habit of copying takes over again.

La WaitGroup copiée : le Wait qui n'aboutit jamaisThe copied WaitGroup: the Wait that never completes
func worker(wg sync.WaitGroup) {   // COPIE de la WaitGroup
    defer wg.Done()                // … Done sur la copie, l'original l'ignore
    doWork()
}

var wg sync.WaitGroup
wg.Add(1)
go worker(wg)        // on passe une copie → le compteur de l'original reste à 1
wg.Wait()            // deadlock : il n'atteindra jamais 0
// $ go vet → worker passes lock by value: sync.WaitGroup contains sync.noCopy

C'est le grand classique des débuts en concurrence. Le code semble idiomatique — Add, une goroutine, defer Done, Wait — et pourtant il bloque pour toujours. La cause est invisible à l'œil nu : un wg sans étoile dans la signature de worker. La WaitGroup embarque un champ noCopy exactement pour que go vet hurle ici. Le message « contains sync.noCopy » est ta bouée : il transforme un deadlock mystérieux en une ligne à corriger.It's the great classic of concurrency beginnings. The code looks idiomatic — Add, a goroutine, defer Done, Wait — and yet it blocks forever. The cause is invisible to the naked eye: a wg without a star in worker's signature. The WaitGroup embeds a noCopy field exactly so go vet screams here. The 'contains sync.noCopy' message is your lifeline: it turns a mysterious deadlock into one line to fix.

La clôture du volume 6Closing volume 6

On a parcouru tout l'arc de la copie. Le numéro 1 : tout est copié, c'est le défaut. Le numéro 2 : le receveur déclare si un type est une valeur ou une identité. Le numéro 3 : certaines identités — les verrous — refusent formellement la copie, et l'outil le vérifie. La même question, posée trois fois, à trois échelles : copié ou partagé ? Au niveau d'un argument, d'un type, d'une garantie de synchronisation. Savoir y répondre, c'est tenir la moitié de ce qui fait un programme Go correct.We've traversed the whole arc of the copy. Issue 1: everything is copied, that's the default. Issue 2: the receiver declares whether a type is a value or an identity. Issue 3: some identities — locks — formally refuse the copy, and the tool verifies it. The same question, asked three times, at three scales: copied or shared? At the level of an argument, of a type, of a synchronization guarantee. Knowing how to answer it is holding half of what makes a Go program correct.

On a beaucoup écrit defer. On va enfin le regarder.We've written defer a lot. We're finally going to look at it.

Tu l'auras remarqué : dans presque tous les exemples de sûreté de ce volume, un defer veillait — defer mu.Unlock(), defer wg.Done(). On s'en est servi comme d'un réflexe, sans l'interroger. Le prochain volume en fait son sujet. defer planifie du code pour la sortie de la fonction, quelle que soit cette sortie — retour normal, erreur, ou panic — et les defer s'exécutent en pile, dans l'ordre inverse de leur déclaration. C'est l'outil qui permet de libérer une ressource juste à côté de l'endroit où on l'a acquise, et de ne jamais l'oublier. Mais il a ses propres surprises : ce qu'il capture, quand exactement il s'exécute, et le piège de l'erreur de defer f.Close() qu'on laisse filer sans la regarder. Vol. 7 №01 — defer, la promesse différée.You'll have noticed: in nearly every safety example of this volume, a defer kept watch — defer mu.Unlock(), defer wg.Done(). We used it as a reflex, without questioning it. The next volume makes it its subject. defer schedules code for the function's exit, whatever that exit — normal return, error, or panic — and defers run in a stack, in the reverse order of their declaration. It's the tool that lets you free a resource right next to where you acquired it, and never forget it. But it has its own surprises: what it captures, when exactly it runs, and the trap of the error from defer f.Close() that slips away unlooked-at. Vol. 7 №01 — defer, the deferred promise.

Un type de synchronisation ne se copie pas — il se partage par adresse. Et quand l'habitude de copier revient, go vet monte la garde.A synchronization type isn't copied — it's shared by address. And when the habit of copying returns, go vet stands guard.
№ 05Bilan & éditoWrap-up & editorial2 min

« Tout est copié » a une exception, une seule, et le langage la défend lui-même : ce qui tient un verrou ne se copie pas."Everything is copied" has one exception, just one, and the language defends it itself: what holds a lock isn't copied.

Ce numéro a fermé le volume sur la zone rouge de la sémantique de valeur. Certains types portent un état d'identité — un verrou, un compteur de synchronisation, une garantie d'unicité — dont l'intérêt même est de n'exister qu'en un exemplaire ; les copier ne les isole pas, il les casse. Un mutex copié verrouille dans le vide ; une WaitGroup copiée bloque le Wait pour toujours. La mécanique est simple : un verrou est un état partagé, pas une donnée, et le dupliquer brise l'unicité dont toute coordination dépend. Le langage ne s'en remet pas à ta vigilance : go vet embarque copylocks, qui repère statiquement tout type satisfaisant sync.Locker copié par valeur — passé, retourné, parcouru, reçu en receveur valeur — et te le signale avant l'exécution. Et tu peux retourner l'outil à ton profit : un champ noCopy minuscule rend ton propre type non-copiable, à coût nul. La règle qui clôt le volume est sans appel : un type de synchronisation se partage par adresse, jamais par valeur. C'est l'aboutissement d'un arc en trois temps — tout est copié, le receveur déclare la nature, et certaines natures interdisent la copie.This issue closed the volume on value semantics' red zone. Some types carry an identity state — a lock, a synchronization counter, a uniqueness guarantee — whose whole point is to exist in a single instance; copying them doesn't isolate them, it breaks them. A copied mutex locks into the void; a copied WaitGroup blocks the Wait forever. The mechanic is simple: a lock is shared state, not data, and duplicating it breaks the uniqueness all coordination depends on. The language doesn't leave it to your vigilance: go vet ships copylocks, which statically spots any type satisfying sync.Locker copied by value — passed, returned, ranged, received as a value receiver — and flags it before execution. And you can turn the tool to your advantage: a tiny noCopy field makes your own type non-copyable, at zero cost. The rule closing the volume is final: a synchronization type is shared by address, never by value. It's the culmination of a three-beat arc — everything is copied, the receiver declares the nature, and some natures forbid the copy.

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
Le verrou copiéThe copied lockUn type à verrou ne se passe et ne se range que par pointeur.A lock type is passed and stored only by pointer.Exclusion brisée, ou deadlock si la copie était prise.Broken exclusion, or deadlock if the copy was held.
copylockscopylocksgo vet interdit, statiquement, toute copie d'un sync.Locker.go vet forbids, statically, any copy of a sync.Locker.Un bug de concurrence muet, qui n'éclate qu'en production.A silent concurrency bug that only erupts in production.
L'idiome noCopyThe noCopy idiomUn champ noCopy rend ton type non-copiable, à coût d'exécution nul.A noCopy field makes your type non-copyable, at zero runtime cost.Rien ne signale qu'on duplique ton type porteur d'identité.Nothing flags that your identity-bearing type is being duplicated.
La familleThe familyMutex, WaitGroup, Once, atomic.*, strings.Builder : tous non-copiables (vet pour les premiers, panic à l'exécution pour le Builder).Mutex, WaitGroup, Once, atomic.*, strings.Builder: all non-copyable (vet for the first ones, a runtime panic for the Builder).Tu copies une WaitGroup, et le Wait du parent ne rend jamais la main.You copy a WaitGroup, and the parent's Wait never returns.
La copie isole partout dans Go — sauf là où l'isolement est une trahison. Un verrou n'a de sens qu'en un exemplaire ; le dupliquer, c'est le dissoudre.The copy isolates everywhere in Go — except where isolation is a betrayal. A lock only makes sense in one instance; duplicating it is dissolving it.
Mot de l'éditeur · clôture du volume 6From the editor · closing volume 6

Le volume 6 répondait à une question : qui possède cette donnée ? Le volume 7 en pose une autre : quand, exactement, ce code va-t-il s'exécuter ?Volume 6 answered one question: who owns this data? Volume 7 asks another: when, exactly, will this code run?

Trois numéros pour une seule idée, déclinée en gravité croissante. Tout est copié : c'est le don par défaut de Go, l'isolation offerte sans qu'on la demande. Le receveur choisit, pour un type entier, s'il est une valeur qu'on duplique librement ou une identité qu'on manipule par l'original. Et certaines identités — celles qui coordonnent des goroutines — poussent la logique jusqu'à interdire formellement la copie, sous la garde de go vet. Ce qui frappe, en refermant le volume, c'est la cohérence : une seule question, copié ou partagé, traverse l'argument de fonction, la déclaration de méthode, et la garantie de synchronisation. Go ne multiplie pas les règles ; il applique la même, partout, jusqu'à ses conséquences extrêmes. Et il rend chaque réponse visible — dans un &, dans une étoile de receveur, dans un message de vet. C'est la même honnêteté qu'au volume 5 sur la mémoire : montrer qui touche quoi, et n'accorder le partage que sur demande explicite. Avec ce volume, l'inquiétude « cette valeur, est-elle à moi ou partagée ? » devient un réflexe, et tout un pan des bugs Go cesse d'être mystérieux.Three issues for a single idea, declined in rising gravity. Everything is copied: it's Go's default gift, isolation offered without being asked. The receiver chooses, for a whole type, whether it's a value duplicated freely or an identity handled through the original. And some identities — those coordinating goroutines — push the logic to formally forbidding the copy, under go vet's watch. What strikes you, closing the volume, is the coherence: a single question, copied or shared, runs through the function argument, the method declaration, and the synchronization guarantee. Go doesn't multiply rules; it applies the same one, everywhere, to its extreme consequences. And it makes each answer visible — in an &, in a receiver's star, in a vet message. It's the same honesty as volume 5 about memory: show who touches what, and grant sharing only on explicit request. With this volume, the worry 'this value, is it mine or shared?' becomes a reflex, and a whole swath of Go bugs stops being mysterious.

Le prochain volume change d'axe. Jusqu'ici, on a beaucoup parlé d'espace — où vit une valeur, qui la possède, qui peut la changer. On va parler de temps. Dans presque tous les exemples de sûreté qu'on vient d'écrire, un petit mot revenait, qu'on a utilisé comme une évidence : defer. defer mu.Unlock() collé au Lock, defer wg.Done() en tête de goroutine, defer f.Close() après l'ouverture. C'est l'outil par lequel Go relie l'acquisition d'une ressource à sa libération, en les écrivant côte à côte, et en garantissant que la seconde aura lieu quelle que soit la façon dont la fonction se termine — retour, erreur, ou panic. Mais defer n'est pas le geste anodin qu'on croit : il a une sémantique précise sur ce qu'il capture et quand il s'évalue, et un piège fameux dans l'erreur qu'un defer f.Close() laisse filer sans la regarder. On quitte la question « à qui est cette valeur ? » pour « quand ce code s'exécutera-t-il ? ». Vol. 7 №01 — defer, la promesse différée.The next volume shifts axis. So far, we've spoken a lot of space — where a value lives, who owns it, who can change it. We're going to speak of time. In nearly every safety example we've just written, a little word recurred, used as self-evident: defer. defer mu.Unlock() glued to the Lock, defer wg.Done() atop a goroutine, defer f.Close() after the open. It's the tool by which Go ties a resource's acquisition to its release, writing them side by side, and guaranteeing the second happens however the function ends — return, error, or panic. But defer isn't the trivial gesture you think: it has a precise semantics about what it captures and when it evaluates, and a famous trap in the error a defer f.Close() lets slip away unlooked-at. We leave the question 'whose value is this?' for 'when will this code run?'. Vol. 7 №01 — defer, the deferred promise.