Threads, Processes & GIL

Introduction

Python's GIL (Global Interpreter Lock) means threads can't run Python bytecode in parallel — use multiprocessing or concurrent.futures for CPU-bound work.

Understanding the topic

Core concepts to understand:

• GIL = one Python instruction at a time per process.
• Threads good for I/O, bad for CPU.
• multiprocessing bypasses the GIL.
• concurrent.futures is the high-level API.

Syntax reference

Visual flow / code:

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

# I/O-bound: threads
with ThreadPoolExecutor(max_workers=8) as pool:
    results = list(pool.map(fetch_url, urls))

# CPU-bound: processes
with ProcessPoolExecutor() as pool:
    results = list(pool.map(heavy_compute, data))

Execution workflow

Real-world use

Python 3.13 introduces an experimental no-GIL build (PEP 703). For now: threads for I/O, processes for CPU, async for thousands of connections.

Best practices

• Threads for I/O.
• Processes for CPU.
• Async for very-high-fanout I/O.

Common mistakes

• Trying to speed up NumPy with threads — usually works (releases GIL), but pure Python doesn't.

Hands-on exercise

Interview preparation — practice these questions:

• What is the GIL?
• Threads vs processes vs async — when?
• Will Python remove the GIL?

Summary

In summary: GIL serializes Python bytecode. Pick the right tool for the workload.