Le GIL : pourquoi deux threads ne calculent pas en parallèle The GIL: why two threads don't compute in parallel

Lancer deux threads pour accélérer un calcul semble une évidence — sur un CPU à plusieurs cœurs, ils devraient se partager le travail. Pourtant, en Python, un seul thread exécute du bytecode à la fois. Le GIL sérialise le calcul ; seule l'attente — un fichier, un réseau, un timer — libère vraiment un cœur pour un autre thread. Spinning up two threads to speed up a computation looks obvious — on a multi-core CPU, they should split the work. Yet in Python, only one thread executes bytecode at a time. The GIL serializes computation; only waiting — a file, a network call, a timer — actually frees a core for another thread.

Audience
Dev qui a lancé threading.Thread sur une boucle de calcul et se demande pourquoi ça n'est pas allé plus vite Dev who spun up threading.Thread on a compute loop and wonders why it wasn't any faster
ChapitresChapters
5
LectureReading
≈ 19 min
NiveauLevel
●●●○
Date
Juil 2026 Jul 2026

GILThreadingConcurrence

SommaireContents ·
№ 01CadrageFraming3 min

Deux threads sur un CPU à huit cœurs — et pourtant, aucune accélération. Le calcul reste sérialisé.Two threads on an eight-core CPU — and yet no speedup at all. The computation stays serialized.

Le générateur suspendu du n°21 mettait sa propre exécution en pause, à un point précis, pour rendre la main. Un thread, lui, semble tourner en même temps que les autres — c'est même la promesse du multithreading : répartir le travail sur plusieurs cœurs pour aller plus vite. Cette intuition est fausse en Python, et ce numéro explique pourquoi : le Global Interpreter Lock, le GIL, garantit qu'un seul thread exécute du bytecode Python à un instant donné, quel que soit le nombre de cœurs disponibles. Diviser un calcul en deux threads ne le fait donc pas tourner deux fois plus vite — au mieux, ça ne change rien ; au pire, la coordination entre threads ralentit l'ensemble.Issue №21's suspended generator paused its own execution at a precise point to hand back control. A thread, by contrast, looks like it runs at the same time as the others — that's even the promise of multithreading: spread the work across multiple cores to go faster. That intuition is wrong in Python, and this issue explains why: the Global Interpreter Lock, the GIL, guarantees that only one thread executes Python bytecode at any given instant, no matter how many cores are available. Splitting a computation across two threads therefore doesn't run it twice as fast — at best, nothing changes; at worst, the coordination between threads slows the whole thing down.

Deux threads sur un calcul pur : la durée ne se divise pasTwo threads on a pure computation: the duration doesn't split
import threading, time

def compter(n):
    while n > 0:
        n -= 1

debut = time.perf_counter()
compter(50_000_000)
print("séquentiel :", time.perf_counter() - debut)

debut = time.perf_counter()
t1 = threading.Thread(target=compter, args=(25_000_000,))
t2 = threading.Thread(target=compter, args=(25_000_000,))
t1.start(); t2.start()
t1.join(); t2.join()
print("deux threads :", time.perf_counter() - debut)

# sur un CPU à 8 cœurs, on attend une division par ~2 -- il n'y en a
# quasiment aucune. Parfois, c'est même PLUS LENT que la version
# séquentielle.
Le réflexe du numéroThis issue's reflex

Avant de lancer un threading.Thread, demande : ce travail attend-il quelque chose (I/O), ou calcule-t-il (CPU) ? Le GIL ne pénalise que le second cas.Before spinning up a threading.Thread, ask: is this work waiting on something (I/O), or computing (CPU)? The GIL only penalizes the latter.

№ 02La surpriseThe surprise4 min

Le même outil — threading — accélère l'attente réseau et n'accélère jamais le calcul.The same tool — threading — speeds up network waiting and never speeds up computation.

La surprise n'est pas que le threading soit inutile en Python — c'est qu'il est utile pour une seule catégorie de travail, et inutile pour l'autre, et que rien dans la syntaxe ne distingue les deux cas. Un thread qui calcule garde le GIL en continu : les autres threads attendent leur tour, exactement comme s'il n'y avait qu'un seul cœur. Un thread qui attend une réponse réseau, une lecture disque, ou tout appel bloquant implémenté en C, relâche le GIL pendant cette attente — et un autre thread peut alors s'exécuter à sa place. Le threading Python parallélise l'attente, jamais le calcul.The surprise isn't that threading is useless in Python — it's that it helps for exactly one category of work, and does nothing for the other, and nothing in the syntax distinguishes the two cases. A thread that computes holds the GIL continuously: the other threads wait their turn, exactly as if there were only one core. A thread that waits on a network response, a disk read, or any blocking call implemented in C, releases the GIL during that wait — and another thread can then run in its place. Python threading parallelizes waiting, never computing.

Le GIL reste détenu tout le long du calculThe GIL stays held for the entire computation
import threading, time

def calculer(n):
    total = 0
    for i in range(n):
        total += i * i
    return total

debut = time.perf_counter()
threads = [threading.Thread(target=calculer, args=(20_000_000,)) for _ in range(4)]
for t in threads: t.start()
for t in threads: t.join()
print("4 threads, calcul pur :", time.perf_counter() - debut)
# quasiment le même temps que 4 appels séquentiels -- le GIL sérialise
# le bytecode, quel que soit le nombre de threads en attente derrière lui
№ 03La mécaniqueThe mechanics5 min

Le GIL n'est pas partagé entre threads — il est prêté, un instant à la fois, à un seul.The GIL isn't shared between threads — it's lent, one instant at a time, to exactly one.

Le GIL est un verrou unique, détenu par l'interpréteur CPython, que tout thread doit posséder pour exécuter du bytecode Python. Un thread qui calcule le garde environ 5 millisecondes (sys.getswitchinterval()) avant que l'interpréteur ne force une bascule vers un autre thread candidat — ou plus tôt, s'il rencontre un appel bloquant implémenté en C (lecture de fichier, requête réseau, time.sleep) qui relâche volontairement le GIL pendant l'attente. Ce mécanisme explique tout : deux threads de calcul se relaient sur le même unique GIL, jamais en parallèle. Pour du parallélisme réel sur du calcul pur, il faut sortir du thread et passer au processus — multiprocessing lance des interpréteurs Python séparés, chacun avec son propre GIL, donc réellement indépendants sur des cœurs distincts.The GIL is a single lock, held by the CPython interpreter, that any thread must own to execute Python bytecode. A thread that computes holds it for roughly 5 milliseconds (sys.getswitchinterval()) before the interpreter forces a switch to another candidate thread — or sooner, if it hits a blocking call implemented in C (file read, network request, time.sleep) that voluntarily releases the GIL during the wait. This mechanism explains everything: two computing threads take turns on the same single GIL, never in parallel. For real parallelism on pure computation, you have to leave the thread and move to the process — multiprocessing spawns separate Python interpreters, each with its own GIL, therefore genuinely independent on distinct cores.

Le GIL bascule toutes les ~5ms, ou plus tôt sur un appel bloquantThe GIL switches roughly every 5ms, or sooner on a blocking call
import sys

print(sys.getswitchinterval())   # 0.005 -- 5 millisecondes, par défaut

# toutes les ~5ms (ou avant, si le thread courant fait un appel
# bloquant), l'interpréteur relâche le GIL et laisse un autre thread
# candidat le récupérer. Un seul thread à la fois exécute du bytecode --
# le GIL n'est pas partagé, il est PRÊTÉ, séquentiellement.

sys.setswitchinterval(0.001)   # changer la fréquence de bascule --
# ne fait pas paralléliser le calcul pour autant, juste basculer plus
# souvent entre threads qui restent, eux, strictement séquentiels
multiprocessing : un GIL par processus, un cœur par processusmultiprocessing: one GIL per process, one core per process
from multiprocessing import Process
import time

def calculer(n):
    total = 0
    for i in range(n):
        total += i * i

if __name__ == "__main__":   # obligatoire : sous spawn (macOS, Windows),
                             # chaque processus fils réimporte ce module
    debut = time.perf_counter()
    processus = [Process(target=calculer, args=(20_000_000,)) for _ in range(4)]
    for p in processus: p.start()
    for p in processus: p.join()
    print("4 processus :", time.perf_counter() - debut)

# chaque Process a SON PROPRE interpréteur, donc SON PROPRE GIL --
# quatre GIL distincts, quatre cœurs qui calculent vraiment en parallèle.
# Le prix : pas de mémoire partagée par défaut, coût de démarrage plus
# élevé, et toute donnée échangée doit être sérialisée (pickle).
Ce que le GIL protège réellementWhat the GIL actually protects

Le GIL existe pour simplifier la gestion mémoire de CPython — en particulier le comptage de références (Vol. IX), qui deviendrait sujet à des conditions de course sans lui. C'est le prix payé pour un modèle mémoire simple et une intégration C facile, pas un oubli d'implémentation. Il existe désormais un build sans GIL (PEP 703) : expérimental en 3.13, officiellement supporté depuis 3.14 (PEP 779) sous le nom python3.14t — mais le build standard, celui qu'installe presque tout le monde, garde son GIL.The GIL exists to simplify CPython's memory management — in particular reference counting (Vol. IX), which would become subject to race conditions without it. It's the price paid for a simple memory model and easy C integration, not an implementation oversight. A GIL-free build now exists (PEP 703): experimental in 3.13, officially supported since 3.14 (PEP 779) as python3.14t — but the standard build, the one almost everyone installs, keeps its GIL.

№ 04Le piègeThe trap4 min

Le mythe du « thread rapide » : ajouter des threads à un calcul peut le rendre plus lent, pas plus rapide.The "fast thread" myth: adding threads to a computation can make it slower, not faster.

Le piège n'est pas seulement l'absence de gain — c'est la possibilité d'une perte. Chaque bascule du GIL entre deux threads a un coût réel : sauvegarder l'état du thread qui cède la main, restaurer celui du suivant. Sur un calcul pur découpé entre plusieurs threads, ce coût de bascule s'additionne au temps de calcul total, sans jamais le diviser puisque le calcul reste séquentiel au niveau du GIL. Le résultat peut être une version « parallélisée » plus lente que l'original séquentiel. La solution n'est pas d'ajouter encore plus de threads : c'est de reconnaître que du travail CPU-bound a besoin de processus, pas de threads — multiprocessing.Pool répartit le calcul sur des cœurs réellement distincts, chacun avec son propre GIL.The trap isn't just the absence of gain — it's the possibility of a loss. Every GIL switch between two threads has a real cost: saving the state of the thread giving up control, restoring the next one's. On a pure computation split across several threads, that switching cost adds to the total computation time, never dividing it since the computation stays serialized at the GIL level. The result can be a 'parallelized' version slower than the sequential original. The fix isn't adding even more threads: it's recognizing that CPU-bound work needs processes, not threads — multiprocessing.Pool spreads the computation across genuinely distinct cores, each with its own GIL.

2 threads peut être plus lent que 1 seul, sur du calcul pur2 threads can be slower than just 1, on pure computation
import threading, time

def compter(n):
    while n > 0:
        n -= 1

debut = time.perf_counter()
compter(40_000_000)
print("1 thread (séquentiel) :", time.perf_counter() - debut)

debut = time.perf_counter()
t1 = threading.Thread(target=compter, args=(20_000_000,))
t2 = threading.Thread(target=compter, args=(20_000_000,))
t1.start(); t2.start()
t1.join(); t2.join()
print("2 threads :", time.perf_counter() - debut)

# le second chiffre peut être ÉGAL ou PIRE que le premier -- chaque
# bascule du GIL entre les deux threads a un coût (sauvegarder/restaurer
# l'état), et ce coût s'ajoute au temps de calcul sans jamais le diviser.
# "Deux threads" a semblé plus rapide sur le papier. Le CPU ne ment pas.
Le réflexe à retenirThe reflex to keep

threading pour l'attente (réseau, disque, timer) ; multiprocessing pour le calcul (CPU). Mélanger les deux réflexes ne produit pas une erreur visible — juste une lenteur silencieuse, ou un gain qui n'arrive jamais.threading for waiting (network, disk, timer); multiprocessing for computation (CPU). Mixing up the two reflexes doesn't produce a visible error — just silent slowness, or a gain that never arrives.

№ 05Bilan & éditoRecap & editorial2 min

Ce numéro en une tableThis issue in one table

№No.TitreTitleTensionTension
22Le GILThe GILThreads pour l'I/O, jamais pour le calcul (build standard) ; multiprocessing pour le vrai parallélismeThreads for I/O, never for computation (standard build); multiprocessing for real parallelism
Un thread ne demande pas la permission de calculer en parallèle. Le GIL la lui refuse, silencieusement, à chaque bascule.A thread never asks permission to compute in parallel. The GIL silently denies it, at every switch.
Prochain numéro — №23Next issue — No. 23

Ce numéro a montré que le GIL sérialise le calcul mais libère un thread pendant l'attente. Le №23 pousse cette idée jusqu'au bout : et si un seul thread suffisait, du moment qu'il sait rendre la main de lui-même ? asyncio construit exactement ça — une boucle d'événements coopérative, mono-thread, où await est le point de suspension volontaire.This issue showed that the GIL serializes computation but frees a thread during waiting. No. 23 pushes that idea to its conclusion: what if a single thread were enough, as long as it knows how to hand back control on its own? asyncio builds exactly that — a cooperative, single-threaded event loop, where await is the voluntary suspension point.