All 15 Concurrency (asyncio/threading/multiprocessing) questions
More in Concurrency (asyncio/threading/multiprocessing)
How does the Global Interpreter Lock (GIL) affect CPU-bound versus I/O-bound multithreaded programs differently? How do you run multiple coroutines concurrently using asyncio.gather()? How do you protect shared mutable state from race conditions when using multiple threads, using threading.Lock? How does multiprocessing.Pool let you parallelize a CPU-bound function across multiple worker processes? How does asyncio's event loop schedule and switch between multiple coroutines, and what makes this cooperative rather than preemptive? How do you safely run a blocking, synchronous function from within an asyncio coroutine without freezing the event loop? How do you share data between processes using multiprocessing, given that separate processes don't share memory the way threads do? How would you implement a producer-consumer pattern combining a thread-safe queue.Queue with multiple worker threads? How do you correctly cancel a running asyncio task, and how should the task itself handle the resulting CancelledError? How would you use concurrent.futures.ProcessPoolExecutor together with asyncio to run CPU-bound work without blocking the event loop?
Advertisement
Python › Concurrency (asyncio/threading/multiprocessing)

What is a race condition, and how does it differ from a deadlock?

Intermediate

Answer

A race condition occurs when the outcome of concurrent operations depends on unpredictable timing, typically causing lost updates or corrupted shared state; a deadlock occurs when two or more threads/processes each hold a resource the other needs and wait forever, making no progress at all. Race conditions produce wrong results silently; deadlocks freeze the program entirely.
# Race condition: lost updates without a lock
counter = 0
def increment():
    global counter
    counter += 1  # not atomic: read, add, write can interleave between threads

# Deadlock: each thread waits on a lock the other holds
# Thread A: lock1.acquire(); lock2.acquire()
# Thread B: lock2.acquire(); lock1.acquire()  -- opposite order, can deadlock
Real-world example Debugging a counter that mysteriously undercounts under load (race condition) versus a service that hangs indefinitely under specific load patterns (deadlock).

Common follow-ups: What is the standard technique (like consistent lock ordering) for avoiding deadlocks in multi-lock code?

Debugging & Profiling
All 15 Concurrency (asyncio/threading/multiprocessing) questions