Threading and the GIL

Threads in Python

The threading module provides OS-level threads. Threads share memory and are great for I/O-bound workloads (network, disk). Due to the GIL (covered below), they don't speed up CPU-bound Python code.

import threading
import time

def worker(n: int):
    print(f"worker {n} starting")
    time.sleep(1)
    print(f"worker {n} done")

threads = [threading.Thread(target=worker, args=(i,)) for i in range(5)]
for t in threads: t.start()
for t in threads: t.join()                   # wait for completion

Daemon Threads

t = threading.Thread(target=poll_loop, daemon=True)
t.start()
# Daemon threads die when the main program exits — useful for background loops

The Global Interpreter Lock (GIL)

CPython's GIL ensures only one thread executes Python bytecode at a time. This means:

• I/O-bound work: Threading helps. While one thread waits on a socket, another can run.
• CPU-bound work: Threading does NOT help — the GIL serializes execution. Use multiprocessing instead.
• C extensions (NumPy, etc.): Release the GIL during heavy work — threading helps there.

# CPU-bound — threading provides ~0 speedup
def crunch():
    return sum(i * i for i in range(10_000_000))

# I/O-bound — threading provides big speedup
def fetch(url):
    return requests.get(url).text

concurrent.futures — High-Level API

The recommended way to use threads in modern Python. Submit functions to an executor, get futures back.

from concurrent.futures import ThreadPoolExecutor
import requests

urls = ["https://example.com"] * 20

with ThreadPoolExecutor(max_workers=10) as ex:
    # map: in input order
    for result in ex.map(lambda u: requests.get(u).status_code, urls):
        print(result)

    # Or submit individually for finer control
    futures = [ex.submit(requests.get, u) for u in urls]
    for f in futures:
        print(f.result().status_code)

Synchronization Primitives

Even with the GIL, Python operations are not atomic at the bytecode level. Use locks for shared mutable state.

import threading

counter = 0
lock = threading.Lock()

def increment(n):
    global counter
    for _ in range(n):
        with lock:           # automatic acquire/release
            counter += 1

Primitives

Producer/Consumer with Queue

import queue, threading

q = queue.Queue(maxsize=100)

def producer():
    for i in range(1000):
        q.put(i)            # blocks if full
    q.put(None)               # sentinel

def consumer():
    while True:
        item = q.get()
        if item is None: break
        process(item)
        q.task_done()

Thread-Local Storage

Each thread gets its own attributes — useful for request-scoped data without explicit plumbing.

import threading

local_data = threading.local()

def handle_request(req):
    local_data.user = req.user
    process()

def process():
    print(local_data.user)         # whatever was set in THIS thread