The Secret Life of Python: Understanding the GIL

Why your threads aren't speeding up your code

#Python #GIL #Concurrency #Performance

---

Margaret is a senior software engineer. Timothy is her junior colleague. They work in a grand Victorian library in London — the kind of place where code quality is the unspoken objective, and craftsmanship is the only thing that matters.

Episode 35

Timothy was on a roll. He had mastered Threads, Locks, and Queues. His Chess Club app was running smoothly, but now he wanted to add a "Grandmaster Analysis" feature—a heavy math engine that calculated millions of possible chess positions to find the perfect move.

"I’ll just throw eight threads at it," Timothy told Margaret, eyes gleaming. "One for each core of my processor. It should be eight times faster!"

He wrote the code, started eight threads, and watched his CPU monitor. To his horror, the analysis took longer than it did with a single thread. Even worse, only one of his CPU cores was doing any real work.

"Margaret," Timothy groaned, "my threads are all healthy. The Safe Room is working, and the Conveyor Belt is moving. But it’s like there’s an invisible ceiling. Why is Python only using one hand when I gave it eight?"

---

The One-Mic Policy

Margaret walked to the whiteboard and drew a giant, heavy padlock around the entire Python logo.

"You’ve met the GIL, Timothy—the Global Interpreter Lock."

"Think of Python like a very sophisticated talk show," Margaret explained. "You can have as many guests (threads) as you want sitting on the stage. They can all think, they can all wait for their turn, and they can all hold their own notes."

"But," she said, drawing a single microphone in the center, "there is only one microphone. In the standard version of Python (CPython), only one thread is allowed to speak—or execute a line of code—at any given millisecond. The GIL is the person standing off-stage holding that microphone, making sure only one guest is talking at a time."

---

Why the Ceiling Exists

"But why?" Timothy asked. "If I have eight cores, why can't I have eight microphones?"

"Because of the way Python handles memory," Margaret said. "Back in the day, to keep Python's internal memory management simple and thread-safe, the creators decided it was easier to just lock the whole interpreter. It prevents your threads from accidentally corrupting Python's own internal 'soul' while they work."

"This is why Threading is great for I/O—like waiting for a file to save or a web page to load. While one thread is 'waiting,' it hands the microphone to someone else. But for Heavy Math, threads are useless because they spend all their time fighting for the microphone instead of doing the math."

---

Breaking the Ceiling

Timothy looked at his "Analysis" engine. "So I’m stuck? I can’t use my whole processor?"

"Not with Threads," Margaret said, her eyes twinkling. "To use all eight cores for heavy math, you don't need more guests on one stage. You need eight different stages."

"Next time," she said, "we’re going to stop talking about Threading and start talking about Multiprocessing. We’re going to give every worker their own microphone, their own memory, and their own copy of Python."

Timothy looked up at the "Glass Ceiling." He finally understood that to go faster, he didn't need to manage the chaos better—he needed to escape it entirely.

---

Margaret’s Cheat Sheet: Understanding the GIL

The Core Concept

• The GIL (Global Interpreter Lock): A mechanism in CPython (the standard version of Python) that ensures only one thread executes bytecode at a time.
• The Bottleneck: Because of the GIL, multi-threaded programs cannot use multiple CPU cores for raw computation (CPU-bound tasks).

Decision Guide: Threads vs. Processes

• Wait for files or networks - Use Threading. Waiting releases the "Mic" (GIL) for others.
• Heavy math/number crunching - Use Multiprocessing. Every worker gets their own "Mic" and CPU core.
• Handle 10K+ connections - Use Asyncio. Efficient juggling on a single "Stage."

The Specialist's Wisdom

• CPython Specific: This limitation applies to CPython. Other versions like Jython or IronPython don't have a GIL, but they are less common in the "Specialist's" daily toolkit.
• Queues Still Matter: Queues (from Episode 34) are still thread-safe and useful for I/O tasks. The GIL doesn't make them unsafe; it just limits how much "talking" they can do at once.

---

Aaron Rose is a software engineer and technology writer at tech-reader.blog. 

Catch up on the latest explainer videos, podcasts, and industry discussions below.