Threading vs Multiprocessing vs Asyncio

The three concurrency primitives. The GIL, when each beats the others, and how to pick. FIND_VIDEO: search 'python threading multiprocessing asyncio GIL' — recommended channel: mCoding / Real Python. Aim for 11 min or under.

13 minutesVideo LessonPDF notes

Watch Threading vs Multiprocessing vs Asyncio on YouTube

🎯 Free Guest Mode: You are learning for free. Sign in to save your completion progress and quiz answers.

Loading progress...

Key moments

Concurrency Models Overview — The instructor outlines the three Python concurrency models and defines the distinction between IO-bound and CPU-bound workloads.
Synchronous Baseline — The instructor implements a sequential work simulation to establish a baseline execution time.
Threading with ThreadPoolExecutor — The instructor demonstrates concurrent IO execution using ThreadPoolExecutor and processes results with as_completed.
Multiprocessing for CPU Workloads — The instructor applies ProcessPoolExecutor to parallelize CPU-heavy calculations across distinct processes.
Async IO Setup — The instructor introduces coroutines, async/await syntax, and non-blocking sleep within an event loop.

PDF notes

Bottom line: You will evaluate whether a workload is IO-bound or CPU-bound and select the optimal Python concurrency model. You will implement concurrent workflows using ThreadPoolExecutor, ProcessPoolExecutor, and asyncio to eliminate sequential bottlenecks.

This lesson on Threading vs Multiprocessing vs Asyncio is hands-on and example-driven. You will evaluate whether a workload is IO-bound or CPU-bound and select the optimal Python concurrency model. You will implement concurrent workflows using ThreadPoolExecutor, ProcessPoolExecutor, and asyncio to eliminate sequential bottlenecks.

What You'll Be Able To Do

Differentiate between IO-bound and CPU-bound workloads to select the appropriate concurrency model.
Implement concurrent execution for IO-bound tasks using ThreadPoolExecutor and process completed futures with as_completed.
Execute CPU-intensive tasks in parallel across multiple processes using ProcessPoolExecutor to bypass the GIL.
Structure asynchronous coroutines using async/await syntax and non-blocking asyncio operations.

Detailed Concept Walkthrough

1. Task Classification and Synchronous Execution

Synchronous execution processes tasks sequentially, blocking progress until each task finishes. Classifying workloads as IO-bound (waiting on external resources) or CPU-bound (intensive computation) determines how to optimize them.

Mechanism: Sequential code executes line-by-line within a single thread, where total execution time equals the sum of all individual task durations.
Under the Hood: IO-bound operations leave the CPU idle while waiting on network or disk responses, whereas CPU-bound operations fully saturate processor cores with active bytecode execution.
Best Practice: Measure baseline performance using synchronous functions before refactoring to concurrency to quantify actual speedups.

import time

def simulate_work(task_id: int) -> str:
    time.sleep(1)  # Simulates waiting on an IO-bound operation
    return f"Task {task_id} done"

def run_sync() -> None:
    start = time.perf_counter()
    results = [simulate_work(i) for i in range(3)]
    print(f"Sync finished in {time.perf_counter() - start:.2f}s")

run_sync()

Key Takeaway: Synchronous execution is inefficient for IO-bound waiting periods and fails to utilize multiple cores for CPU-heavy tasks.

2. Threading with ThreadPoolExecutor

Threading allows multiple threads of execution within a single process to handle IO-bound tasks concurrently. Python threads share memory space, making thread creation lightweight.

Mechanism: The ThreadPoolExecutor manages a pool of worker threads, submitting tasks as futures and collecting them as they finish.
Under the Hood: The Global Interpreter Lock (GIL) prevents multiple native threads from executing Python bytecode simultaneously, but the GIL is released during IO operations, allowing other threads to run.
Execution Flow: Using concurrent.futures.as_completed yields results in the order they finish rather than the order they were submitted, reducing idle wait times.

from concurrent.futures import ThreadPoolExecutor, as_completed
import time

def simulate_io(task_id: int) -> str:
    time.sleep(1)
    return f"IO Task {task_id} completed"

def run_threading() -> None:
    with ThreadPoolExecutor(max_workers=3) as executor:
        futures = [executor.submit(simulate_io, i) for i in range(3)]
        for future in as_completed(futures):
            print(future.result())

run_threading()

Key Takeaway: Use ThreadPoolExecutor for IO-bound operations where the GIL is released during blocking network or filesystem calls.

3. Multiprocessing with ProcessPoolExecutor

Multiprocessing creates independent OS-level processes, each with its own Python interpreter and GIL, enabling true parallel execution across multiple CPU cores.

Mechanism: ProcessPoolExecutor distributes CPU-bound tasks across separate worker processes that execute computations in parallel.
Under the Hood: Because each process has an isolated memory space and dedicated GIL, CPU-heavy tasks run simultaneously without interpreter contention.
Nuance: Spawning processes and serializing data across process boundaries introduces higher memory overhead and startup latency compared to threading.

from concurrent.futures import ProcessPoolExecutor, as_completed

def do_cpu_work(n: int) -> int:
    return sum(i * i for i in range(n))

def run_multiprocessing() -> None:
    with ProcessPoolExecutor() as executor:
        futures = [executor.submit(do_cpu_work, 10_000_000) for _ in range(4)]
        results = [f.result() for f in as_completed(futures)]
        print("CPU Results:", results)

if __name__ == "__main__":
    run_multiprocessing()

Key Takeaway: Use ProcessPoolExecutor for CPU-bound computations to bypass the GIL at the cost of higher memory and inter-process overhead.

4. Asynchronous IO with Asyncio

Asyncio implements cooperative multitasking within a single thread using an event loop and coroutines, offering high-throughput concurrency for IO-bound operations.

Mechanism: Coroutines defined with async def yield control back to the event loop using await whenever they encounter non-blocking operations.
Under the Hood: An event loop tracks pending tasks and resumes them when their IO operations complete, avoiding the memory overhead of operating system threads.
Syntax Rule: You must use non-blocking asynchronous calls like asyncio.sleep() rather than blocking standard library calls like time.sleep().

import asyncio

async def do_async_work(task_id: int) -> str:
    await asyncio.sleep(1)  # Non-blocking pause
    return f"Async Task {task_id} completed"

async def main() -> None:
    tasks = [do_async_work(i) for i in range(3)]
    results = await asyncio.gather(*tasks)
    print(results)

asyncio.run(main())

Key Takeaway: Asyncio delivers lightweight, high-concurrency IO handling in a single thread via non-blocking coroutines and an event loop.

Topics Covered in Threading vs Multiprocessing vs Asyncio

Concurrency Models Overview (0:00 - 0:37) — The instructor outlines the three Python concurrency models and defines the distinction between IO-bound and CPU-bound workloads.
Synchronous Baseline (0:48 - 2:22) — The instructor implements a sequential work simulation to establish a baseline execution time.
Threading with ThreadPoolExecutor (2:22 - 5:08) — The instructor demonstrates concurrent IO execution using ThreadPoolExecutor and processes results with as_completed.
Multiprocessing for CPU Workloads (5:08 - 7:39) — The instructor applies ProcessPoolExecutor to parallelize CPU-heavy calculations across distinct processes.
Async IO Setup (7:50 - 9:02) — The instructor introduces coroutines, async/await syntax, and non-blocking sleep within an event loop.

Python Cheat Sheet

concurrent.futures.ThreadPoolExecutor — Manages a pool of threads for IO-bound concurrency
```
with ThreadPoolExecutor(max_workers=4) as ex: pass
```
concurrent.futures.ProcessPoolExecutor — Manages separate worker processes for parallel CPU workloads
```
with ProcessPoolExecutor() as ex: pass
```
executor.submit(fn, *args) — Schedules callable execution and returns a Future object
```
future = executor.submit(simulate_work, 1)
```
concurrent.futures.as_completed(futures) — Yields futures as they finish running
```
for f in as_completed(futures): res = f.result()
```
async def / await — Defines coroutines and pauses execution until awaitable completes
```
async def get_data(): await asyncio.sleep(0.1)
```
asyncio.gather(*coros) — Runs multiple coroutines concurrently and returns aggregated results
```
results = await asyncio.gather(c1(), c2())
```
asyncio.run(coro) — Creates event loop, runs root coroutine, and closes loop
```
asyncio.run(main())
```

Comparison Table

Model	Ideal Workload	GIL Impact	Resource Overhead
Threading	IO-bound operations	Shared GIL (released on IO)	Low memory overhead
Multiprocessing	CPU-bound computations	Separate GIL per process	High memory overhead
Asyncio	High-concurrency IO-bound	Single GIL (single-threaded)	Minimal memory overhead

Common Pitfalls

Mistake: Using ThreadPoolExecutor for CPU-bound computations expecting speedups. Avoid: Use ProcessPoolExecutor to bypass the GIL and utilize multiple CPU cores.
Mistake: Calling blocking time.sleep() inside an asyncio coroutine. Avoid: Use non-blocking asyncio.sleep() to allow the event loop to switch tasks.
Mistake: Invoking ProcessPoolExecutor without an if name == 'main' guard. Avoid: Protect multiprocessing entry points with the main guard to prevent recursive process spawning.

FAQs

Why does threading not speed up CPU-bound tasks in Python? The Global Interpreter Lock (GIL) permits only one thread to execute Python bytecode at a time, creating contention rather than parallelism on CPU work.
When should I choose asyncio over ThreadPoolExecutor for IO-bound work? Choose asyncio when handling thousands of concurrent non-blocking connections efficiently; choose ThreadPoolExecutor when working with existing synchronous, blocking libraries.
What is the difference between time.sleep() and asyncio.sleep()? time.sleep() blocks the entire operating system thread, while asyncio.sleep() yields control to the event loop so other coroutines can run.

Common pitfalls

Mistake: Using ThreadPoolExecutor for CPU-bound computations expecting speedups. Avoid: Use ProcessPoolExecutor to bypass the GIL and utilize multiple CPU cores.
Mistake: Calling blocking time.sleep() inside an asyncio coroutine. Avoid: Use non-blocking asyncio.sleep() to allow the event loop to switch tasks.
Mistake: Invoking ProcessPoolExecutor without an if __name__ == '__main__' guard. Avoid: Protect multiprocessing entry points with the main guard to prevent recursive process spawning.

This tutorial provides a practical, step-by-step guide to using **Python Concurrency Models** within *Python (utilizing the concurrent.futures and asyncio standard libraries)*. After watching, a learner will be able to distinguish between IO-bound and CPU-bound tasks and select the appropriate concurrency technique (Threading, Multiprocessing, or Asyncio) for optimized execution. ### **Curriculum Alignment: Topics Covered** 1. **Introduction to Concurrency Models and Task Types (00:00 - 00:37)** * **Concept:** Overview of the three primary concurrency mechanisms in Python (threading, multiprocessing, asyncio) and the fundamental distinction between IO-bound tasks (waiting) and CPU-bound tasks (computing). * **Action:** Identifying the goal: moving from synchronous execution to optimized concurrent execution. 2. **Establishing a Synchronous Baseline (00:48 - 02:22)** * **Concept:** Understanding synchronous execution where tasks run sequentially, waiting for one task to finish before the next one starts. * **Action:** Defining a simulated work function (`simulate some work`) and implementing a `run_sync` function to measure the baseline execution time. 3. **Implementing Concurrency with Threading (IO-Bound) (02:22 - 05:08)** * **Concept:** Explaining threading's suitability for IO-bound tasks due to the Global Interpreter Lock (GIL) being released during waiting periods, allowing other threads to run. * **Action:** Implementing the `run_threading` function using the `concurrent.futures.ThreadPoolExecutor` and managing results using `as_completed`. 4. **Implementing Parallelism with Multiprocessing (CPU-Bound) (05:08 - 07:39)** * **Concept:** Understanding multiprocessing, which uses separate processes (each with its own GIL) to achieve true parallel execution, making it ideal for CPU-bound work despite higher overhead. * **Action:** Defining a new CPU-bound function (`do_CPU_work`) and implementing the `run_multiprocessing` function using the `concurrent.futures.ProcessPoolExecutor`. 5. **Understanding and Setting Up Async IO (07:50 - 09:02)** * **Concept:** Introduction to Async IO as an efficient, single-threaded model utilizing an event loop and coroutines for IO-bound tasks, requiring `async`/`await` syntax. * **Action:** Importing `asyncio` and defining the first asynchronous function (`do_async_work`), utilizing `asyncio.sleep` (non-blocking) instead of `time.sleep`. ### **Learning Outcomes** * **Proficiency:** Successfully distinguish between IO-bound tasks (network, file access) and CPU-bound tasks (heavy calculation) and apply the correct Python concurrency model. * **Workflow Management:** Implement modern concurrent workflows using `ThreadPoolExecutor` and `ProcessPoolExecutor` via the robust `concurrent.futures` module. * **Tooling:** Comfortably use the `concurrent.futures` module functions (`submit`, `as_completed`) and understand the fundamental requirements for using the `asyncio` module (`async`, `await`). ### **Advanced/Tricky Concepts** * **The Global Interpreter Lock (GIL):** Acknowledging that the GIL prevents true parallel execution of Python bytecode across multiple threads, limiting threading primarily to IO-bound scenarios where the GIL is released. * **Process vs. Thread Overhead:** Understanding the trade-off that while multiprocessing allows true parallelism, it incurs greater memory usage and overhead compared to threading. * **Non-blocking Sleep:** Recognizing the difference between `time.sleep()` (blocking the entire thread/process) and `asyncio.sleep()` (non-blocking, yielding control back to the event loop).

Frequently asked questions

Why does threading not speed up CPU-bound tasks in Python?

The Global Interpreter Lock (GIL) permits only one thread to execute Python bytecode at a time, creating contention rather than parallelism on CPU work.

When should I choose asyncio over ThreadPoolExecutor for IO-bound work?

Choose asyncio when handling thousands of concurrent non-blocking connections efficiently; choose ThreadPoolExecutor when working with existing synchronous, blocking libraries.

What is the difference between time.sleep() and asyncio.sleep()?

time.sleep() blocks the entire operating system thread, while asyncio.sleep() yields control to the event loop so other coroutines can run.

How was this lesson?

Your feedback helps us refine explanations and catch bugs.