When do you use threads, processes or asyncio?

The choice follows the bottleneck. Threads share memory and are cheap to start, but the GIL serialises Python bytecode. Processes have separate memory and their own GIL, so they achieve true CPU parallelism at the cost of startup time and inter-process communication.

from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor

def fetch(url):
    return client.get(url).status_code

def crunch(data):
    return sum(value * value for value in data)

with ThreadPoolExecutor(max_workers=8) as pool:
    statuses = list(pool.map(fetch, urls))

with ProcessPoolExecutor(max_workers=4) as pool:
    totals = list(pool.map(crunch, chunks))

Trade-offs

• Threads: shared memory, lower startup cost, but locks and race conditions
• Processes: true parallelism, isolation, but serialisation overhead and higher memory use
• asyncio: many concurrent I/O operations in one thread, but one blocking call stalls the loop
• Process pools need picklable payloads and careful handling of large results

Shared mutable state is the main hazard with threads. Prefer queues, immutable messages or per-thread state over locks around large critical sections. With processes, minimise data crossing the boundary because pickling and copying can dominate runtime.