Concurrency: Threads and Processes 🧵

Two different problems

Nearly all confusion about Python concurrency comes from not asking this question first. The answer determines the tool, and using the wrong one makes your program slower, not faster.

The GIL, without the mythology

CPython has a Global Interpreter Lock: a single lock that means only one thread executes Python bytecode at a time. It exists because it makes the interpreter simpler and single-threaded code faster, and because CPython's memory management is not thread-safe without it.

The consequences, stated precisely:

• Threads do not speed up pure-Python CPU work. Four threads doing arithmetic take about as long as one, plus overhead.
• Threads absolutely do speed up waiting. The lock is released while a thread waits on the network, a disk or a lock, so a hundred threads can wait at the same time.
• Well-written C extensions release the lock too. NumPy's heavy numeric work is genuinely parallel across threads.
• It is not part of the language. Jython and IronPython have no GIL, and Python 3.13 shipped an experimental free-threaded build that removes it. The rules above are about CPython today.

Threads, where they shine

import time
from concurrent.futures import ThreadPoolExecutor


def fetch(page):
    """Pretend to download something: mostly waiting."""
    time.sleep(0.1)
    return f"page {page}: 200 OK"


start = time.perf_counter()
sequential = [fetch(n) for n in range(8)]
sequential_time = time.perf_counter() - start

start = time.perf_counter()
with ThreadPoolExecutor(max_workers=8) as pool:
    threaded = list(pool.map(fetch, range(8)))
threaded_time = time.perf_counter() - start

print(sequential[0])
print(f"sequential took about 0.8s: {0.7 < sequential_time < 1.2}")
print(f"threaded took about 0.1s:   {threaded_time < 0.4}")
print(f"same results: {sequential == threaded}")

page 0: 200 OK
sequential took about 0.8s: True
threaded took about 0.1s:   True
same results: True

Eight tasks that each wait a tenth of a second: eight tenths sequentially, one tenth in parallel. The GIL is irrelevant here because none of these threads wants the CPU. This is most real-world concurrency: talking to APIs, databases and files.

Processes, for actual CPU work

from concurrent.futures import ProcessPoolExecutor


def count_primes(limit):
    """Deliberately CPU-heavy."""
    count = 0
    for n in range(2, limit):
        if all(n % d for d in range(2, int(n ** 0.5) + 1)):
            count += 1
    return count


if __name__ == "__main__":
    with ProcessPoolExecutor(max_workers=4) as pool:
        results = list(pool.map(count_primes, [20000, 20000, 20000, 20000]))
    print(results)

Each process is a separate Python interpreter with its own GIL, so they genuinely run on different cores. The costs are real: starting a process is slow (tens of milliseconds), and every argument and result must be pickled and copied between processes. Use them for chunky work, never for tiny tasks.

Choosing

The dangerous part: shared state

import threading

counter = 0


def increment_unsafe():
    global counter
    for _ in range(100_000):
        counter += 1          # read, add, write: three steps, interruptible


threads = [threading.Thread(target=increment_unsafe) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()

print(f"expected 400000, got {counter}")
print(f"correct? {counter == 400_000}")

That program is a genuine race condition: counter += 1 is three operations, and a thread can be interrupted between them, losing an update. On modern CPython you will often get the right answer anyway, which is worse than always getting it wrong, because the bug only appears under load, in production, at 3am.

import threading

counter = 0
lock = threading.Lock()


def increment_safe():
    global counter
    for _ in range(100_000):
        with lock:            # only one thread inside at a time
            counter += 1


threads = [threading.Thread(target=increment_safe) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()

print(f"expected 400000, got {counter}")

expected 400000, got 400000

The better answer: do not share

from concurrent.futures import ThreadPoolExecutor


def work(n):
    """Pure function: takes a value, returns a value, shares nothing."""
    return n * n


with ThreadPoolExecutor(max_workers=4) as pool:
    results = list(pool.map(work, range(6)))

print(results)
print(sum(results))

[0, 1, 4, 9, 16, 25]
55

No lock, no race, no possibility of one. Threads that communicate by returning values rather than by mutating shared state are dramatically easier to get right. When you must share, use queue.Queue, which is thread-safe by design, rather than a list and a prayer.

Futures, when tasks finish at different times

import time
from concurrent.futures import ThreadPoolExecutor, as_completed


def fetch(page):
    time.sleep(0.05 * (4 - page))       # later pages finish first
    return f"page {page}"


with ThreadPoolExecutor(max_workers=4) as pool:
    futures = {pool.submit(fetch, n): n for n in range(4)}
    for future in as_completed(futures):
        print("finished:", future.result())

finished: page 3
finished: page 2
finished: page 1
finished: page 0

submit returns a Future: a promise of a result. as_completed yields them in the order they finish, so you can start processing the fast ones without waiting for the slow one. Exceptions are re-raised when you call .result(), which is a considerate design: nothing is swallowed.

import threading

results = []


def work(n):
    results.append(n * n)


threads = [threading.Thread(target=work, args=(i,)) for i in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()

import threading

results = []
lock = threading.Lock()


def work(n):
    value = n * n
    with lock:
        results.append(value)


threads = [threading.Thread(target=work, args=(i,)) for i in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()

print(sorted(results))

[0, 1, 4, 9]

from concurrent.futures import ThreadPoolExecutor

with ThreadPoolExecutor(max_workers=4) as pool:
    results = list(pool.map(lambda n: n * n, range(4)))

print(results)

[0, 1, 4, 9]

import time
from concurrent.futures import ThreadPoolExecutor


def slow_task(n):
    time.sleep(0.05)
    return n


def timed(label, func):
    start = time.perf_counter()
    result = func()
    elapsed = time.perf_counter() - start
    print(f"{label:12} {elapsed:.2f}s")
    return elapsed, result


sequential, _ = timed("sequential", lambda: [slow_task(n) for n in range(10)])

def threaded_run():
    with ThreadPoolExecutor(max_workers=10) as pool:
        return list(pool.map(slow_task, range(10)))

threaded, _ = timed("threaded", threaded_run)

print(f"speedup: {sequential / threaded:.1f}x")
print(f"worth it: {sequential / threaded > 2}")