HardExperience level: 8-15 years2 min read

What is the GIL (Global Interpreter Lock) and what are its implications?

Reviewed by Gurusankar M.

Asked inAmazonGoogleMicrosoft
#gil#global interpreter lock#concurrency#cpython#threads
Report issue

Short Answer

The GIL is a mutex in CPython that allows only one thread to execute Python bytecode at a time. It makes single-threaded code and memory management simpler/safer but prevents CPU-bound threads from running Python in true parallel. I/O releases the GIL, so threads still help I/O-bound work; CPU-bound work needs multiprocessing.

On this page

Concept Made Simple

Coffee Chat Question

“What is the GIL (Global Interpreter Lock) and what are its implications?”

Remember It Faster

Mind Map Answer

What
one thread runs Python bytecode at a time
Where
CPython (not Jython/PyPy-STM)
Hurts
CPU-bound multithreading
Fine for
I/O-bound (GIL released on I/O)

Learn by Doing

Hands-on Keyboard

python
# Two CPU-bound threads do NOT run in parallel (GIL):
import threading
def burn():
    x = 0
    for _ in range(10_000_000):
        x += 1

t1 = threading.Thread(target=burn)
t2 = threading.Thread(target=burn)
t1.start(); t2.start(); t1.join(); t2.join()
# ~same wall time as running burn() twice sequentially
# For real parallelism use multiprocessing instead

Think Beyond the Expected

What If?

If the GIL limits parallelism, why does CPython keep it?

It makes CPython's memory management (reference counting) thread-safe without fine-grained locking, keeps C extensions simpler, and makes single-threaded code fast — the common case. Removing it historically slowed single-threaded programs. Work like the optional free-threaded (no-GIL) builds aims to relax this while preserving compatibility.

Real World

The GIL is why 'add threads' doesn't speed up number-crunching in pure Python, pushing teams to multiprocessing, C/NumPy (which releases the GIL), or async for I/O — a defining constraint interviewers probe for senior Python roles.

Interviewer's Expectation

Keywords they're listening for:

  • one thread runs bytecode at a time
  • CPython-specific
  • blocks CPU-bound parallelism
  • I/O releases the GIL
  • workarounds: multiprocessing / C ext / async

Common Mistakes

  • Expecting threads to parallelize CPU work
  • Thinking the GIL affects all Python implementations
  • Believing the GIL makes all code thread-safe (it doesn't for compound ops)

Best Practices

  • Use multiprocessing for CPU-bound parallelism
  • Use threads/asyncio for I/O-bound concurrency
  • Offload heavy math to NumPy/C that releases the GIL

Follow-up Questions

  1. How do NumPy/C extensions release the GIL?
  2. What is the free-threaded / no-GIL CPython effort?
  3. How does asyncio achieve concurrency despite the GIL?

Continue Learning with AI

Take this question deeper with your favourite AI assistant. Pick a depth, copy the prompt, or open it directly — AI is your learning companion, not a shortcut.

Plain-language foundations

I'm preparing for a software engineering interview and want to understand this from scratch, as a beginner.

Topic: GIL (Python)
Interview question: "What is the GIL (Global Interpreter Lock) and what are its implications?"

Please:
1. Explain the core idea in simple, plain language, using an everyday analogy.
2. Define any technical terms you use.
3. Walk through one small, concrete example.
4. Finish with a single sentence I can easily remember.

Keep the tone friendly and assume I'm new to this topic.
Open inChatGPTGeminiClaude

Was this answer helpful?

Affiliate links

Tools for Your Developer Workspace

Equipment for a comfortable, productive setup.

As an Amazon Associate I earn from qualifying purchases.