Concurrency Basics

Core lesson 01

The Global Interpreter Lock (GIL) allows only one thread to execute Python bytecode at a time in CPython, so threading gives no speedup for CPU-bound work — but still helps for I/O-bound work.

CPython's memory management isn't thread-safe by default, so the interpreter uses a single global lock to protect it — only the thread holding the GIL can run Python bytecode. Threads still get interleaved (the GIL is released periodically), which is why threading works great for I/O-bound tasks (a thread waiting on a network call releases the GIL so another can run) but doesn't parallelize CPU-bound number crunching across cores the way a purely thread-based language would.

import threading, time

def cpu_bound():
    total = 0
    for i in range(20_000_000):
        total += i
    return total

start = time.time()
threads = [threading.Thread(target=cpu_bound) for _ in range(2)]
[t.start() for t in threads]
[t.join() for t in threads]
print("threaded:", time.time() - start)
# roughly the same or worse than running cpu_bound() twice sequentially,
# because the GIL prevents true parallel execution of Python bytecode

Core lesson 02

multiprocessing runs separate processes, each with its own GIL, giving true CPU parallelism at the cost of higher memory use and needing to serialize (pickle) data passed between processes.

Since each process in multiprocessing has its own interpreter and GIL, CPU-bound work genuinely runs in parallel across cores — ideal for number crunching or image processing. The cost: processes don't share memory, so passing data between them requires pickling it, which adds overhead and means not all objects can even be shared. Threading, by contrast, shares memory directly, which is lighter weight and better suited to I/O-bound work, where the GIL is released during the wait anyway.

from multiprocessing import Pool

def square(n):
    return n * n

if __name__ == "__main__":
    with Pool(processes=4) as pool:
        results = pool.map(square, range(10))
    print(results)   # computed across 4 real processes

Core lesson 03

asyncio runs everything on a single thread using an event loop; coroutines cooperatively yield at each await, so many I/O-bound tasks can be 'in flight' concurrently without thread/process overhead — but one blocking call freezes everything.

Where threading relies on OS preemption and multiprocessing uses separate OS processes, asyncio achieves concurrency within a single thread: an event loop runs one coroutine until it hits an await on something not yet ready, then switches to another ready coroutine. This is extremely lightweight and ideal for I/O-bound workloads with many concurrent waits — but any single blocking, non-async call stalls the entire event loop, since there's no OS-level preemption to save you.

import asyncio

async def fetch(name, delay):
    print(f"{name} starting")
    await asyncio.sleep(delay)
    print(f"{name} done")
    return name

async def main():
    results = await asyncio.gather(fetch("A", 2), fetch("B", 1))
    print(results)

asyncio.run(main())
# both start immediately; total time is ~2s, not 3s -- they ran concurrently

Threading:      [T1-run][T2-run][T1-run][T2-run]...  (GIL: 1 at a time, OS-preempted)
Multiprocessing:[P1-run||||||||||]                     (separate GILs, true parallel)
                [P2-run||||||||||]
Asyncio:        [coro A][await][coro B][await][coro A resumes]...  (1 thread, cooperative)