Le scheduler The scheduler

Des centaines de milliers de goroutines tiennent sur une poignée de threads OS — c'est le scheduler M:N qui les fait danser. GOMAXPROCS, préemption, et la vieille histoire de la goroutine en boucle serrée qui affamait les autres (et pourquoi c'est presque fini). Hundreds of thousands of goroutines ride on a handful of OS threads — the M:N scheduler makes them dance. GOMAXPROCS, preemption, and the old tale of the tight-loop goroutine that starved the others (and why that's nearly over).

Audience
Dev qui déploie des services Go dans des containers, ou qui veut comprendre comment le runtime gère les goroutines Dev deploying Go services in containers, or who wants to understand how the runtime manages goroutines
ChapitresChapters
5
LectureReading
≈ 17 min
NiveauLevel
●●●●
Date
Août 2028 Aug 2028

SchedulerGOMAXPROCSPréemption

SommaireContents ·
№ 01CadrageFraming3 min

Des millions de goroutines sur quelques threads OS. Le scheduler M:N de Go les fait danser — GOMAXPROCS contrôle combien peuvent danser en même temps.Millions of goroutines on a few OS threads. Go's M:N scheduler makes them dance — GOMAXPROCS controls how many can dance at once.

Le volume 1 a posé les goroutines comme unité de concurrence légère. Ce dernier numéro répond à la question laissée ouverte : comment des centaines de milliers de goroutines peuvent-elles coexister sur une poignée de threads OS ? La réponse est le scheduler M:N — M goroutines sur N threads OS — implémenté par le runtime Go. La structure du scheduler repose sur trois entités. Les G (goroutines) sont les unités de travail légères : chaque goroutine démarre avec environ 2 Ko de pile et peut atteindre 1 Go par croissance dynamique. Les M (machines) sont les threads OS : créés par le runtime, ils peuvent être bien plus nombreux que GOMAXPROCS car un M bloqué sur un syscall est remplacé par un nouveau M pour ne pas bloquer les autres goroutines. Les P (processeurs) sont les contextes d'exécution : il en existe exactement GOMAXPROCS, et chaque M qui veut exécuter des G doit en acquérir un. GOMAXPROCS est donc le vrai levier de parallélisme : il contrôle combien de goroutines peuvent s'exécuter simultanément sur des cœurs différents. Par défaut depuis Go 1.5, GOMAXPROCS vaut le nombre de CPUs logiques — le bon défaut dans la plupart des cas, sauf dans des environnements containerisés où les CPUs disponibles ne sont pas ceux de la machine hôte — un angle mort que Go 1.25 a enfin comblé en lisant le quota CPU du cgroup sous Linux.Volume 1 introduced goroutines as lightweight concurrency units. This last issue answers the question left open: how can hundreds of thousands of goroutines coexist on a handful of OS threads? The answer is the M:N scheduler — M goroutines on N OS threads — implemented by the Go runtime. The scheduler's structure rests on three entities. Gs (goroutines) are lightweight work units: each goroutine starts with about 2KB of stack and can reach 1GB through dynamic growth. Ms (machines) are OS threads: created by the runtime, they can be far more numerous than GOMAXPROCS because a blocked M (on a syscall) is replaced by a new M to not block other goroutines. Ps (processors) are execution contexts: there are exactly GOMAXPROCS of them, and each M that wants to run Gs must acquire one. GOMAXPROCS is therefore the real parallelism lever: it controls how many goroutines can run simultaneously on different cores. By default since Go 1.5, GOMAXPROCS equals the number of logical CPUs — the right default in most cases, except in containerized environments where available CPUs don't match the host machine's — a blind spot Go 1.25 finally closed by reading the cgroup CPU quota on Linux.

La structure G/M/P et GODEBUG=schedtraceThe G/M/P structure and GODEBUG=schedtrace
// Le scheduler Go : G sur M via P
//
// G (Goroutine) : unité de travail légère — ~2KB de pile initiale
// M (Machine)   : thread OS — créé par le runtime, bloque sur les syscalls
// P (Processor) : contexte d'exécution — exactement GOMAXPROCS P existent
//
// Chaque P a une run queue locale de G à exécuter.
// Un M doit acquérir un P pour exécuter des G.
// Si un M bloque (syscall, cgo), un autre M prend le P et continue.

// Voir l'état du scheduler en temps réel :
GOMAXPROCS=4 GODEBUG=schedtrace=1000 go run ./server.go
// toutes les 1000ms : goroutines en cours, en attente, threads, ...
// SCHED 1000ms: gomaxprocs=4 idleprocs=2 threads=6 spinningthreads=1 runqueue=3 ...
G / M / P — la trinité du schedulerG / M / P — the scheduler trinity
G
Goroutine
unité de travail · ~2KB · millions possibles
M
Machine
thread OS · bloque sur syscalls · N > GOMAXPROCS
P
Processor
contexte d'exécution · exactement GOMAXPROCS

Un M doit acquérir un P pour exécuter des G. GOMAXPROCS P → au plus GOMAXPROCS G en parallèle. Les G en attente sont dans les run queues — locales à chaque P, ou globale.An M must acquire a P to run Gs. GOMAXPROCS P → at most GOMAXPROCS Gs in parallel. Waiting Gs are in run queues — local to each P, or global.

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

« Mes goroutines ne progressent pas en parallèle — est-ce un bug du scheduler ? » Presque toujours non. La vraie question est : GOMAXPROCS est-il bien configuré pour l'environnement d'exécution ? Dans un container avec limite CPU de 0.5 core, GOMAXPROCS=runtime.NumCPU() lit le nombre de CPUs de l'hôte (32, 64...) et crée 32 P — dont 31 sont inutiles. Avant Go 1.25, la bibliothèque uber-go/automaxprocs corrige ça en lisant les CFS quotas Linux ; depuis Go 1.25, le runtime le fait lui-même."My goroutines don't progress in parallel — is it a scheduler bug?" Almost never. The real question is: is GOMAXPROCS properly configured for the execution environment? In a container with a 0.5 core CPU limit, GOMAXPROCS=runtime.NumCPU() reads the host's CPU count (32, 64...) and creates 32 P — 31 of which are useless. Before Go 1.25, the uber-go/automaxprocs library fixes this by reading Linux CFS quotas; since Go 1.25, the runtime does it itself.

Pourquoi M peut être > GOMAXPROCSWhy M can be > GOMAXPROCS

Quand une goroutine fait un syscall bloquant (lecture fichier, appel réseau lent), le M qui l'exécute bloque avec elle. Pour ne pas laisser le P inutilisé, le runtime détache le P du M bloqué et le donne à un autre M (ou en crée un nouveau). Résultat : le nombre de threads OS (M) peut dépasser GOMAXPROCS quand beaucoup de goroutines font des I/O bloquants simultanément. La limite de M se règle avec debug.SetMaxThreads (défaut : 10 000). Les goroutines utilisant des I/O non-bloquants (net.Conn avec le network poller) ne créent pas de nouveaux M — elles se parquent dans le poller et le M est libéré.When a goroutine makes a blocking syscall (file read, slow network call), the M running it blocks with it. To not leave the P unused, the runtime detaches the P from the blocked M and gives it to another M (or creates a new one). Result: the number of OS threads (M) can exceed GOMAXPROCS when many goroutines make blocking I/O simultaneously. The M limit is set with debug.SetMaxThreads (default: 10,000). Goroutines using non-blocking I/O (net.Conn with the network poller) don't create new Ms — they park in the poller and the M is released.

№ 02La surpriseThe surprise4 min

La goroutine en boucle serrée qui affamait le scheduler — et pourquoi c'est presque fini depuis Go 1.14 et la préemption asynchrone.The tight-loop goroutine that starved the scheduler — and why it's mostly over since Go 1.14 and asynchronous preemption.

La surprise historique du scheduler Go est la goroutine affamatrice. Avant Go 1.14, le scheduler était coopératif : une goroutine ne rendait le contrôle que lors d'appels de fonctions, d'opérations channel, de syscalls, ou d'un runtime.Gosched() explicite. Une goroutine en boucle serrée — un calcul pur sans aucun appel de fonction — ne rendait jamais le contrôle. Sur GOMAXPROCS=1, elle monopolisait le seul thread disponible et toutes les autres goroutines étaient bloquées. Sur GOMAXPROCS>1, l'impact était réduit mais les goroutines sur le même P que la boucle affamatrice ne progressaient pas. Ce problème avait des workarounds connus — ajouter runtime.Gosched() dans les boucles longues — mais c'était un défaut de conception. Go 1.14 a introduit la préemption asynchrone : quand une goroutine tourne depuis plus de ~10ms, le moniteur du runtime (sysmon) envoie un signal SIGURG à son thread, et le handler de signal interrompt la goroutine courante même si elle est au milieu d'un calcul pur, sans appel de fonction. Le scheduler injecte un point de vérification dans le flux d'exécution depuis l'extérieur. Depuis Go 1.14, les boucles serrées peuvent être interrompues — le problème de starvation est résolu pour la majorité des cas. Il subsiste des cas limites (code en assembleur, CGo) mais pour le Go pur, la préemption asynchrone garantit l'équité du scheduler.Go scheduler's historical surprise is the starving goroutine. Before Go 1.14, the scheduler was cooperative: a goroutine only yielded control at function calls, channel operations, syscalls, or an explicit runtime.Gosched(). A goroutine in a tight loop — pure computation with no function calls — never yielded. On GOMAXPROCS=1, it monopolized the only available thread and all other goroutines were blocked. On GOMAXPROCS>1, impact was reduced but goroutines on the same P as the starving loop didn't progress. This problem had known workarounds — adding runtime.Gosched() in long loops — but it was a design flaw. Go 1.14 introduced asynchronous preemption: when a goroutine has been running for over ~10ms, the runtime's monitor (sysmon) sends a SIGURG signal to its thread, and the signal handler interrupts the current goroutine even if it's in the middle of pure computation, without a function call. The scheduler injects a checkpoint into the execution flow from outside. Since Go 1.14, tight loops can be interrupted — the starvation problem is solved for the majority of cases. Edge cases remain (assembly code, CGo) but for pure Go, asynchronous preemption guarantees scheduler fairness.

Boucle serrée sur GOMAXPROCS=1 : starvation totale avant Go 1.14Tight loop on GOMAXPROCS=1: total starvation before Go 1.14
// Avant Go 1.14 : une goroutine en boucle serrée pouvait affamer les autres
func main() {
    go func() {
        for {   // boucle serrée sans appel de fonction, sans point de préemption
            // calcul pur — avant Go 1.14, le scheduler ne pouvait pas l'interrompre
        }
    }()

    // Sur GOMAXPROCS=1 : cette goroutine monopolisait le thread OS.
    // La goroutine main ne progressait plus.
    // Sur GOMAXPROCS>1 : impact réduit mais non nul.
    fmt.Println("main progresse ?")   // pouvait ne jamais s'imprimer
}

Sans point de préemption dans la boucle, le scheduler ne pouvait pas reprendre la main. La goroutine monopolisait le thread OS indéfiniment. Le workaround était d'appeler runtime.Gosched() dans la boucle — mais ça obligeait le programmeur à connaître les internals du scheduler. Go 1.14 a rendu ce workaround inutile dans le code Go pur.Without a preemption point in the loop, the scheduler couldn't take back control. The goroutine monopolized the OS thread indefinitely. The workaround was to call runtime.Gosched() in the loop — but that forced the programmer to know scheduler internals. Go 1.14 made this workaround unnecessary in pure Go code.

Le scheduler coopératif avait un angle mort : les boucles pures. La préemption asynchrone de Go 1.14 l'a fermé — sans changer une ligne du code utilisateur.The cooperative scheduler had a blind spot: pure loops. Go 1.14's asynchronous preemption closed it — without changing a single line of user code.
№ 03La mécaniqueThe mechanics5 min

Le work stealing équilibre la charge entre P sans synchronisation. Les goroutines bloquées se parquent — le thread OS est libre pour d'autres.Work stealing balances load across Ps without synchronization. Blocked goroutines park — the OS thread is freed for others.

Le scheduler Go maintient l'équilibre entre les P par work stealing : quand un P a épuisé sa run queue locale, il vole la moitié des goroutines en attente d'un autre P au hasard. Ce mécanisme distribue le travail sans verrou global — chaque P gère sa propre queue et ne synchronise avec les autres qu'au moment du vol. Créer des milliers de goroutines en rafale est donc parfaitement safe : le scheduler les distribuera sur les P disponibles, avec ou sans intervention du programmeur. L'autre mécanique clé est le parking : quand une goroutine se bloque — sur un channel vide, un mutex pris, un timer, une opération réseau — le scheduler la retire du thread et la place en état WAITING. Le thread OS est immédiatement libéré pour exécuter une autre goroutine. C'est ce qui permet à Go de gérer des milliers de connexions réseau concurrentes sans créer autant de threads OS : chaque connexion a sa goroutine, mais une goroutine en attente de données réseau ne consomme pas de thread. Le network poller de Go — implémenté avec epoll sur Linux, kqueue sur macOS — surveille les descripteurs de fichiers réseau et réveille les goroutines concernées quand les données arrivent. C'est la raison pour laquelle net.Conn ne bloque pas un thread OS : c'est du non-bloquant au niveau OS, avec le goroutine parking comme abstraction.The Go scheduler maintains balance across Ps via work stealing: when a P exhausts its local run queue, it steals half the waiting goroutines from a random other P. This mechanism distributes work without a global lock — each P manages its own queue and only synchronizes with others at steal time. Creating thousands of goroutines in a burst is therefore perfectly safe: the scheduler will distribute them across available Ps, with or without programmer intervention. The other key mechanic is parking: when a goroutine blocks — on an empty channel, a taken mutex, a timer, a network operation — the scheduler removes it from the thread and places it in WAITING state. The OS thread is immediately freed to run another goroutine. That's what lets Go handle thousands of concurrent network connections without creating as many OS threads: each connection has its goroutine, but a goroutine waiting for network data consumes no thread. Go's network poller — implemented with epoll on Linux, kqueue on macOS — watches network file descriptors and wakes the relevant goroutines when data arrives. That's why net.Conn doesn't block an OS thread: it's non-blocking at the OS level, with goroutine parking as the abstraction.

Work stealing : un P vide prend la moitié de la queue d'un autreWork stealing: an empty P takes half of another's queue
// Le scheduler distribue le travail par work stealing.
// Chaque P a sa run queue locale (limité à 256 G).
// Une queue globale existe pour les G qui débordent ou qui viennent de syscalls.

// Quand un P épuise sa run queue locale :
// 1. Il consulte la queue globale
// 2. Puis le network poller (goroutines dont l'I/O est prête)
// 3. Puis tente de voler la moitié de la run queue d'un autre P, au hasard
// 4. Sinon, il se met en veille (spinning puis sleep)

// Conséquence : créer des goroutines en burst est OK — le work stealing
// les distribue automatiquement sur tous les P disponibles.
// go func() { … }() × 10 000 : le scheduler gère, pas besoin de pool manuel.

Le work stealing garantit que les goroutines sont consommées au rythme de la capacité disponible. Pas besoin de worker pool manuel pour distribuer le travail sur les CPUs — c'est le scheduler qui le fait. La limite à 256 goroutines par run queue locale évite qu'un seul P accumule trop de travail et devienne une cible de vol permanent.Work stealing guarantees goroutines are consumed at the pace of available capacity. No need for a manual worker pool to distribute work across CPUs — the scheduler does it. The 256-goroutine limit per local run queue prevents a single P from accumulating too much work and becoming a permanent steal target.

Des millions de goroutines sur quelques threads : possible parce qu'une goroutine bloquée libère son thread immédiatement — le scheduler la reprend quand elle est prête.Millions of goroutines on a few threads: possible because a blocked goroutine releases its thread immediately — the scheduler takes it back when it's ready.
№ 04Le piègeThe trap4 min

Dans un container, runtime.NumCPU() lit les CPUs de l'hôte, pas le quota. GOMAXPROCS trop élevé crée des context switches excessifs.In a container, runtime.NumCPU() reads the host's CPUs, not the quota. Too-high GOMAXPROCS creates excessive context switches.

Le piège du scheduler en production est classique et largement documenté, mais encore omniprésent. Depuis Go 1.5, GOMAXPROCS vaut par défaut runtime.NumCPU() — le bon défaut sur une machine physique ou dans une VM avec tous les CPUs. Mais dans un container Docker ou Kubernetes avec une limite CPU de 0.5 core sur une machine hôte à 32 cœurs, runtime.NumCPU() retourne 32 : il lit l'affinité CPU du processus, qui expose les CPUs de l'hôte, pas le quota CFS (Completely Fair Scheduler) alloué au container. Résultat : Go crée 32 P, chacun essayant de s'exécuter sur un thread, alors que le container n'a accès qu'à un demi-cœur. Le noyau doit context-switcher 32 threads sur 0.5 core — des centaines de context switches par seconde, chacun coûtant plusieurs microsecondes de latence. La latence p99 monte, le CPU est saturé par des context switches plutôt que par du vrai travail. Depuis Go 1.25, le runtime lit lui-même cette limite et règle GOMAXPROCS en conséquence ; avant, la solution est uber-go/automaxprocs, une bibliothèque qui lit les CFS quotas Linux au démarrage et fixe GOMAXPROCS en conséquence — un seul import préfixé d'un underscore. C'est devenu un standard de facto dans les équipes qui déploient des services Go dans Kubernetes.The scheduler trap in production is classic and widely documented, but still pervasive. Since Go 1.5, GOMAXPROCS defaults to runtime.NumCPU() — the right default on a physical machine or in a VM with all CPUs. But in a Docker or Kubernetes container with a 0.5 core CPU limit on a 32-core host machine, runtime.NumCPU() returns 32: it reads the process's CPU affinity, which exposes the host's CPUs, not the CFS (Completely Fair Scheduler) quota allocated to the container. Result: Go creates 32 Ps, each trying to run on a thread, while the container has access to only half a core. The kernel must context-switch 32 threads on 0.5 core — hundreds of context switches per second, each costing several microseconds of latency. p99 latency rises, CPU is saturated by context switches rather than real work. Since Go 1.25, the runtime reads that limit itself and sets GOMAXPROCS accordingly; before that, the solution is uber-go/automaxprocs, a library that reads Linux CFS quotas at startup and sets GOMAXPROCS accordingly — a single underscore-prefixed import. It has become a de facto standard in teams deploying Go services in Kubernetes.

GOMAXPROCS=32 dans un container avec 0.5 core : context switches excessifsGOMAXPROCS=32 in a container with 0.5 core: excessive context switches
// Dans un container avec limite CPU : 0.5 core
// La machine hôte a 32 CPUs

import "runtime"

func main() {
    // runtime.NumCPU() lit l'affinité CPU du processus — retourne 32 (les CPUs de l'HÔTE)
    // Go avant 1.5 : GOMAXPROCS=1 par défaut
    // Go depuis 1.5 : GOMAXPROCS=runtime.NumCPU() par défaut → 32

    fmt.Println(runtime.GOMAXPROCS(0))   // affiche 32 avant Go 1.25 (2 depuis : quota lu, minimum 2)

    // Résultat : 32 P créés, mais le container n'a que 0.5 core de quota.
    // 31 P se battent pour 0.5 core → context switches excessifs, latence dégradée.
    // Le scheduler pense avoir 32 CPUs, il en a 0.5.
}

runtime.NumCPU() lit les CPUs physiques de l'hôte — pas les CPUs alloués au container. Un container avec 0.5 core et GOMAXPROCS=32 : le kernel passe plus de temps à context-switcher qu'à exécuter du code. La signature dans les métriques : CPU usage proche de la limite mais latence p99 haute et instable. L'outil de diagnostic : les statistiques du cgroup (nr_throttled dans cpu.stat) montrent un throttling CFS fréquent — le quota brûlé en quelques millisecondes, puis tous les threads gelés jusqu'à la période suivante.runtime.NumCPU() reads the host's physical CPUs — not the CPUs allocated to the container. A container with 0.5 core and GOMAXPROCS=32: the kernel spends more time context-switching than executing code. The metrics signature: CPU usage near the limit but high and unstable p99 latency. The diagnostic tool: the cgroup's statistics (nr_throttled in cpu.stat) show frequent CFS throttling — the quota burned in a few milliseconds, then every thread frozen until the next period.

Les signaux d'un GOMAXPROCS mal configuréSignals of a misconfigured GOMAXPROCS

Trois indicateurs dans les métriques : 1. CPU usage élevé avec latence p99 haute (context switches plutôt que travail). 2. cpu.stat montre un nr_throttled qui grimpe (le quota CFS est épuisé avant la fin de chaque période). 3. schedtrace montre une runqueue qui s'allonge (files d'attente longues malgré GOMAXPROCS élevé).Three indicators in metrics: 1. High CPU usage with high p99 latency (context switches rather than work). 2. cpu.stat shows a climbing nr_throttled (the CFS quota runs out before each period ends). 3. schedtrace shows a growing runqueue (long queues despite high GOMAXPROCS).

GOMAXPROCS et les workers CPU-boundGOMAXPROCS and CPU-bound workers

Pour un programme purement CPU-bound (calcul mathématique, traitement d'image, compilation), GOMAXPROCS = nombre de cœurs disponibles est le bon réglage. Mais pour un service I/O-bound (serveur HTTP, proxy, API), GOMAXPROCS peut être inférieur au nombre de cœurs disponibles sans perte de débit — la plupart des goroutines sont bloquées sur des I/O, pas sur du CPU. Ce n'est pas une raison de baisser GOMAXPROCS manuellement, mais une raison de comprendre que le scheduler Go est optimal par défaut pour les workloads I/O-bound, et qu'augmenter GOMAXPROCS au-delà des cœurs disponibles n'apportera rien.For a purely CPU-bound program (math computation, image processing, compilation), GOMAXPROCS = available cores is the right setting. But for an I/O-bound service (HTTP server, proxy, API), GOMAXPROCS can be lower than available cores without throughput loss — most goroutines are blocked on I/O, not CPU. This is not a reason to manually lower GOMAXPROCS, but a reason to understand that the Go scheduler is optimal by default for I/O-bound workloads, and that increasing GOMAXPROCS beyond available cores will gain nothing.

runtime.NumCPU() dit ce que l'hôte a. automaxprocs dit ce que le container a — c'est la seule vérité qui compte en production.runtime.NumCPU() says what the host has. automaxprocs says what the container has — that's the only truth that matters in production.
№ 05Bilan & édito finalWrap-up & final editorial3 min

G, M, P — trois lettres pour une machine qui fait tourner des millions de goroutines sur quelques threads. Comprendre le scheduler, c'est comprendre pourquoi Go scale.G, M, P — three letters for a machine running millions of goroutines on a few threads. Understanding the scheduler is understanding why Go scales.

Ce dernier numéro a couvert le scheduler M:N de Go — la pièce du runtime qui fait tenir des millions de goroutines sur quelques threads OS. Trois entités : G (goroutines, unités de travail légères à ~2 KB de pile initiale), M (threads OS, créés à la demande quand un M bloque sur un syscall), et P (processeurs logiques, exactement GOMAXPROCS, que tout M doit acquérir pour exécuter des G). Le scheduler équilibre la charge entre P par work stealing : un P vide vole la moitié de la queue d'un P occupé — pas de verrou global, distribution automatique. Une goroutine bloquée (channel, mutex, timer, réseau) se parque et libère son thread immédiatement — c'est ce qui permet 100 000 goroutines sur 8 threads. La surprise historique — la goroutine en boucle serrée qui affamait le scheduler — est résolue depuis Go 1.14 par la préemption asynchrone : un signal SIGURG, envoyé après ~10ms d'exécution continue, garantit qu'aucune goroutine Go pure ne monopolise un P indéfiniment. Le piège de production : dans un container avec limite CPU, runtime.NumCPU() retourne les CPUs de l'hôte, pas le quota. GOMAXPROCS=32 sur 0.5 core crée des centaines de context switches par seconde. Go 1.25 règle ça tout seul ; avant, import _ "go.uber.org/automaxprocs" le résout en une ligne.This last issue covered Go's M:N scheduler — the runtime piece that fits millions of goroutines onto a few OS threads. Three entities: G (goroutines, lightweight work units at ~2KB initial stack), M (OS threads, created on demand when an M blocks on a syscall), and P (logical processors, exactly GOMAXPROCS, that every M must acquire to run Gs). The scheduler balances load across Ps via work stealing: an empty P steals half the queue of a busy P — no global lock, automatic distribution. A blocked goroutine (channel, mutex, timer, network) parks and releases its thread immediately — that's what allows 100,000 goroutines on 8 threads. The historical surprise — the tight-loop goroutine that starved the scheduler — is solved since Go 1.14 by asynchronous preemption: a SIGURG signal, sent after ~10ms of continuous running, guarantees no pure Go goroutine monopolizes a P indefinitely. The production trap: in a container with a CPU limit, runtime.NumCPU() returns the host's CPUs, not the quota. GOMAXPROCS=32 on 0.5 core creates hundreds of context switches per second. Go 1.25 handles it on its own; before that, import _ "go.uber.org/automaxprocs" solves it in one line.

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
G/M/PG/M/PGOMAXPROCS P en parallèle max. M peut dépasser GOMAXPROCS sur syscalls bloquants.At most GOMAXPROCS Ps in parallel. M can exceed GOMAXPROCS on blocking syscalls.Confusion entre parallélisme (P) et concurrence (G illimitées).Confusion between parallelism (P) and concurrency (unlimited Gs).
Préemption asynchroneAsynchronous preemptionDepuis Go 1.14, aucune goroutine Go pure ne peut monopoliser un P plus de ~10ms.Since Go 1.14, no pure Go goroutine can monopolize a P for more than ~10ms.Ajouter runtime.Gosched() inutilement dans des boucles Go pures.Needlessly adding runtime.Gosched() in pure Go loops.
Work stealingWork stealingCréer des milliers de goroutines est safe — le scheduler les distribue automatiquement.Creating thousands of goroutines is safe — the scheduler distributes them automatically.Créer manuellement des worker pools inutiles qui compliquent le code.Manually creating useless worker pools that complicate the code.
GOMAXPROCS en containerGOMAXPROCS in containerGo 1.25+ s'aligne seul sur le quota CPU ; avant, import _ "go.uber.org/automaxprocs".Go 1.25+ aligns with the CPU quota on its own; before that, import _ "go.uber.org/automaxprocs".GOMAXPROCS=32 sur 0.5 core : context switches excessifs, latence p99 dégradée.GOMAXPROCS=32 on 0.5 core: excessive context switches, degraded p99 latency.
Des millions de goroutines sur quelques threads : pas un tour de magie. Une mécanique précise — G/M/P, work stealing, parking — qu'on peut lire dans ses métriques.Millions of goroutines on a few threads: not magic. Precise mechanics — G/M/P, work stealing, parking — that you can read in your metrics.
Mot de l'éditeur · clôture de la newsletterFrom the editor · closing the newsletter

Vingt-sept numéros. Neuf volumes. Une idée par semaine, dépliée jusqu'à ce qu'elle devienne un réflexe.Twenty-seven issues. Nine volumes. One idea per week, unfolded until it becomes a reflex.

La newsletter a commencé par la question la plus simple : qu'est-ce qu'une goroutine, et pourquoi n'est-ce pas un thread ? Elle finit par le scheduler qui les fait tourner — G, M, P, work stealing, préemption asynchrone. Entre les deux, neuf volumes ont couvert le langage de l'extérieur vers l'intérieur. Le volume 1 a posé les goroutines comme unité de base, le WaitGroup comme mécanisme de synchronisation, et la fuite de goroutine comme première erreur à reconnaître. Le volume 2 a ajouté les channels — unidirectionnels, fermables, et le select comme point de convergence entre plusieurs signaux. Le volume 3 a démystifié les interfaces : la valeur concrète et le type, le nil d'interface qui n'est pas nil, et le polymorphisme par comportement plutôt que par hiérarchie. Le volume 4 a couvert les erreurs et la panique : if err != nil, l'enchaînement avec %w, le panic comme rupture d'invariant et le recover comme digue à la frontière. Le volume 5 a décortiqué les slices et maps — vue sur un tableau, append et ses surprises, la map sans ordre et sans concurrence sûre. Le volume 6 a traité la sémantique valeur/pointeur — copier ou partager, receveur valeur ou pointeur, et la copie de mutex qui casse. Le volume 7 a fermé la fonction : defer pour planifier la sortie, la règle de capture du defer, et recover à la frontière sans masquer. Le volume 8 a coordonné les goroutines dans le temps : context.Context comme câble d'annulation, WithTimeout pour les délais, WithValue pour les métadonnées — et la frontière nette entre les deux. Le volume 9 a levé le capot : escape analysis, GC tricolor concurrent, et le scheduler M:N. Vingt-sept numéros, une idée par numéro, dépliée en cinq chapitres. La dernière chose à savoir sur Go — c'est qu'il n'y a pas de dernière chose. Le langage est conçu pour être lu, ses outils pour être utilisés, et la seule façon d'en maîtriser les subtilités est de les rencontrer en pratique. Cette newsletter a donné les cartes ; les routes, c'est toi qui les traceras.The newsletter began with the simplest question: what is a goroutine, and why isn't it a thread? It ends with the scheduler that runs them — G, M, P, work stealing, asynchronous preemption. Between the two, nine volumes covered the language from outside inward. Volume 1 laid goroutines as the base unit, WaitGroup as synchronization mechanism, and goroutine leak as the first error to recognize. Volume 2 added channels — unidirectional, closeable, and select as convergence point between multiple signals. Volume 3 demystified interfaces: the concrete value and type, the interface nil that isn't nil, and polymorphism by behavior rather than hierarchy. Volume 4 covered errors and panic: if err != nil, chaining with %w, panic as invariant rupture and recover as dike at the boundary. Volume 5 dissected slices and maps — view over an array, append and its surprises, the map without order and without safe concurrency. Volume 6 handled value/pointer semantics — copy or share, value or pointer receiver, and the mutex copy that breaks. Volume 7 closed the function: defer to schedule the exit, defer's capture rule, and boundary recover without masking. Volume 8 coordinated goroutines in time: context.Context as cancellation cable, WithTimeout for deadlines, WithValue for metadata — and the sharp line between the two. Volume 9 lifted the hood: escape analysis, concurrent tricolor GC, and the M:N scheduler. Twenty-seven issues, one idea per issue, unfolded across five chapters. The last thing to know about Go — is that there is no last thing. The language is designed to be read, its tools to be used, and the only way to master its subtleties is to meet them in practice. This newsletter gave you the maps; the roads are yours to trace.