Concurrency (asyncio/threading/multiprocessing)

# threading: concurrent, but GIL-limited for CPU-bound work
import threading
threading.Thread(target=cpu_bound_task).start()

# multiprocessing: true parallelism, separate processes
import multiprocessing
multiprocessing.Process(target=cpu_bound_task).start()

Common follow-ups: Why doesn't the GIL limitation apply to multiprocessing the same way it does to threading?

import threading

def greet(name):
    print(f"Hello, {name}!")

thread = threading.Thread(target=greet, args=("Sam",))
thread.start()
thread.join()  # waits for the thread to finish

Common follow-ups: What happens to the main program if it exits before a non-daemon thread finishes?

import asyncio

async def main():
    print("Start")
    await asyncio.sleep(1)
    print("End")

asyncio.run(main())

Common follow-ups: Why should asyncio.run() typically only be called ONCE, at the very top level of a program?

# CPU-bound: threading gives little to no benefit due to the GIL
def cpu_work(): sum(i * i for i in range(10_000_000))

# I/O-bound: threading helps, since the GIL is released during network waits
def io_work(): requests.get("https://example.com")  # GIL released while waiting

Common follow-ups: How does asyncio compare to threading specifically for I/O-bound concurrency, in terms of overhead?

async def fetch(url):
    await asyncio.sleep(1)  # simulated network call
    return f"data from {url}"

async def main():
    results = await asyncio.gather(fetch("a"), fetch("b"), fetch("c"))
    print(results)  # all three run concurrently, total time ~1s, not 3s

Common follow-ups: What happens to the other still-running coroutines if ONE of the gathered coroutines raises an exception?

import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    with lock:
        counter += 1  # protected: no race condition between threads

threads = [threading.Thread(target=increment) for _ in range(1000)]
for t in threads: t.start()
for t in threads: t.join()
print(counter)  # reliably 1000, not less due to lost updates

Common follow-ups: What would happen to the final counter value if the lock were removed entirely, and why?

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)  # [0, 1, 4, 9, ..., 81], computed across 4 parallel processes

Common follow-ups: Why must code using multiprocessing.Pool typically be guarded by 'if __name__ == "__main__":' on Windows?

async def hog_the_loop():
    total = 0
    for i in range(100_000_000):  # no await inside -- blocks the ENTIRE event loop
        total += i
    return total
# Every other coroutine is frozen until this finishes, since it never yields control

Common follow-ups: How would you fix a CPU-bound blocking operation inside an async function without freezing the whole event loop?

import asyncio

def blocking_io():
    import time; time.sleep(2)  # simulates a blocking call
    return "done"

async def main():
    result = await asyncio.to_thread(blocking_io)  # runs in a thread, doesn't block the event loop
    print(result)

Common follow-ups: When would you use a ProcessPoolExecutor instead of a ThreadPoolExecutor for offloading work from asyncio?

from multiprocessing import Process, Queue

def worker(q):
    q.put("result from worker")

if __name__ == "__main__":
    q = Queue()
    p = Process(target=worker, args=(q,))
    p.start()
    p.join()
    print(q.get())  # "result from worker" -- data explicitly passed via the Queue

Common follow-ups: Why is a regular Python list or dict NOT automatically shared between multiprocessing.Process instances the way it would be between threads?