Concurrency Models & Paradigm Classification

Concurrency and parallelism are often conflated, but they represent fundamentally distinct architectural concepts. Concurrency is about dealing with lots of things at once (task composition and interleaving). Parallelism is about doing lots of things at once (simultaneous execution on multiple hardware CPU cores).

Python provides three primary paradigms for concurrent execution, each targeting different hardware constraints and operational trade-offs.

Concurrency SuiteArchitecture

3 Paradigms

Multithreading (shared memory), Multiprocessing (isolated multi-core), and Asyncio (event loop).

1. Concurrency Paradigms at a Glance#

Architecture Diagram

Rendering diagram...

2. Amdahl's Law & The Speedup Ceiling#

The theoretical performance ceiling of parallel execution is governed by Amdahl's Law. Let $S \in [0, 1]$ represent the strictly sequential fraction of a program, and $(1 - S)$ represent the parallelizable fraction, executed across $P$ physical hardware cores with concurrency overhead $O(P)$ :

\text{Speedup}(P) = \frac{1}{S + \frac{1 - S}{P}} - O(P)

The Multithreading Paradox in CPython#

Under standard CPython multithreading for CPU-bound tasks, the Global Interpreter Lock (GIL) constrains bytecode execution to a single core at any instant ( $P_{\text{eff}} = 1$ ):

\text{Speedup}_{\text{GIL\_thread}}(P) = \frac{1}{S + (1 - S)} - \text{GIL\_Contention}(P) \le 1

Running CPU-bound calculations across multiple threads in Python is actually slower than single-threaded execution due to relentless mutex contention and OS context-switching overhead!

3. Asynchronous I/O Latency Mathematics#

For I/O-bound workloads (such as querying web APIs or database sockets), asynchronous cooperative scheduling drastically outperforms synchronous sequential execution.

Let $K$ be the number of network tasks, each having network roundtrip delay $d_i$ and local CPU processing time $c_i \ll d_i$ :

\text{Synchronous Sequential Latency}: L_{\text{sync}} = \sum_{i=1}^K (d_i + c_i)

\text{Asynchronous Concurrent Latency}: L_{\text{async}} = \max_{i=1}^K (d_i) + \sum_{i=1}^K c_i \quad \ll \quad L_{\text{sync}}

Instead of waiting idle for each network response in serial order, an asynchronous event loop overlaps all $K$ network delays concurrently!

4. Comparing the Three Paradigms#

Dimension	Multithreading (`threading`)	Multiprocessing (`multiprocessing`)	Asynchronous I/O (`asyncio`)
Execution Model	Preemptive OS threads (`pthread`/Win32)	Separate OS processes	Single-threaded cooperative tasks
Memory Architecture	Shared heap address space	Completely isolated heap memory	Single shared process heap
GIL Impact	Serializes CPU bytecode execution	Bypasses GIL (one GIL per process)	Irrelevant (single-threaded loop)
Optimal Workload	I/O-bound tasks, C extensions releasing GIL	CPU-bound computation, data science	High-concurrency network sockets (10k+ connections)
Context Switch Cost	Medium (OS thread context switch)	High (OS process context switch)	Ultra-low (coroutine frame swap in RAM)

5. Concept Verification#

Test your understanding of concurrency models:

Concept check

Why does running a CPU-bound calculation across 4 Python threads on a 4-core CPU typically run SLOWER than running it in a single thread?

Concept check

How does asyncio achieve high concurrency for 10,000 simultaneous network connections without crashing server memory?