Process vs Thread0%

Process vs Thread

Beginner12 min read•Updated: Jul 11, 2026

Process vs Thread: Deep Architectural Comparison

Choosing the appropriate concurrency model is one of the most critical engineering decisions in systems programming. In Python, the choice between Threads (threading) and Processes (multiprocessing) impacts memory footprint, throughput, fault tolerance, and developer ergonomics.

1. Operating System Mechanics: Process vs Thread

At the OS kernel level, processes and threads represent different levels of isolation:

Output

1┌────────────────────────────────────────────────────────────────────────┐
2│                        OS Virtual Memory Space                         │
3│                                                                        │
4│   Process 1 (PID 100)                      Process 2 (PID 200)         │
5│  ┌──────────────────────────────┐        ┌───────────────────────────┐ │
6│  │ Private Virtual Memory Space │        │ Isolated Address Space    │ │
7│  │ (Page Tables, MMU, File FDs) │        │ (Cannot read Process 1)   │ │
8│  │                              │        │                           │ │
9│  │  Thread 1      Thread 2      │        │  Thread 3                 │ │
10│  │ ┌─────────┐   ┌─────────┐    │        │ ┌─────────┐               │ │
11│  │ │ Stack   │   │ Stack   │    │        │ │ Stack   │               │ │
12│  │ └─────────┘   └─────────┘    │        │ └─────────┘               │ │
13│  │  Shared Heap & Global State  │        │  Private Heap             │ │
14│  └──────────────────────────────┘        └───────────────────────────┘ │
15└────────────────────────────────────────────────────────────────────────┘

Key Differences

Metric	Thread (`threading`)	Process (`multiprocessing`)
Memory Isolation	Shared heap, global variables, and open file descriptors	Completely isolated address space; memory is private
Context Switching	Low overhead: CPU only swaps registers and stack pointers	High overhead: OS must flush CPU TLB caches and swap page tables
Data Sharing	Direct pointers in shared RAM (requires mutex locks)	Inter-Process Communication (IPC): requires pickling/serialization
Crash Isolation	Zero: A segfault in any thread kills the entire process	High: A crash in a worker process leaves parent and siblings running
CPython GIL Impact	Bound by the single GIL; cannot utilize multiple CPU cores	Each process has its own GIL; full multi-core CPU parallelism
Startup Cost	Low (~microsecond scale)	High (~millisecond scale; requires spawning or forking an interpreter)

2. Quantitative Benchmark: CPU-Bound vs I/O-Bound

The table below summarizes the performance behavior of threads vs processes in CPython:

Python

1import concurrent.futures
2import math
3import os
4import time
5 
6# Workload A: CPU-bound computation
7def cpu_heavy_task(n: int) -> int:
8    return sum(math.isqrt(i) for i in range(n))
9 
10# Workload B: I/O-bound simulated network latency
11def io_heavy_task(duration: float) -> None:
12    time.sleep(duration)
13 
14if __name__ == "__main__":
15    cpu_n = 4_000_000
16    tasks = 4
17 
18    print("--- 1. CPU-BOUND BENCHMARK (4 Heavy Tasks) ---")
19 
20    # Multithreading (Contends for single GIL)
21    start = time.perf_counter()
22    with concurrent.futures.ThreadPoolExecutor(max_workers=tasks) as executor:
23        list(executor.map(cpu_heavy_task, [cpu_n] * tasks))
24    thread_cpu_time = time.perf_counter() - start
25    print(f"ThreadPoolExecutor (CPU):     {thread_cpu_time:.2f}s")
26 
27    # Multiprocessing (Parallel execution on 4 cores)
28    start = time.perf_counter()
29    with concurrent.futures.ProcessPoolExecutor(max_workers=tasks) as executor:
30        list(executor.map(cpu_heavy_task, [cpu_n] * tasks))
31    proc_cpu_time = time.perf_counter() - start
32    print(f"ProcessPoolExecutor (CPU):    {proc_cpu_time:.2f}s (Speedup: {thread_cpu_time/proc_cpu_time:.1f}x)")
33 
34    print("\n--- 2. I/O-BOUND BENCHMARK (4 Simulated Latency Tasks) ---")
35 
36    # Multithreading (Releases GIL during sleep/network)
37    start = time.perf_counter()
38    with concurrent.futures.ThreadPoolExecutor(max_workers=tasks) as executor:
39        list(executor.map(io_heavy_task, [0.2] * tasks))
40    thread_io_time = time.perf_counter() - start
41    print(f"ThreadPoolExecutor (I/O):     {thread_io_time:.2f}s")
42 
43    # Multiprocessing (Also parallel, but with IPC & spawn overhead)
44    start = time.perf_counter()
45    with concurrent.futures.ProcessPoolExecutor(max_workers=tasks) as executor:
46        list(executor.map(io_heavy_task, [0.2] * tasks))
47    proc_io_time = time.perf_counter() - start
48    print(f"ProcessPoolExecutor (I/O):    {proc_io_time:.2f}s")

3. Fault Tolerance & Failure Isolation

In high-reliability backend systems, fault isolation is a critical consideration. If third-party C-extension code (e.g. OpenCV, TensorFlow, or a legacy C shared library) crashes via a null-pointer dereference or segmentation fault:

Threaded Model: The entire application (all threads, all user sessions) crashes immediately.
Multiprocess Model: Only the child worker process dies. The parent supervisor detects the non-zero exit code (exitcode < 0 indicates killed by signal) and can respawn a replacement worker without dropping service availability.

Python

1import multiprocessing
2import os
3import signal
4import time
5 
6def fragile_worker():
7    print(f"[WORKER {os.getpid()}] Processing payload...")
8    time.sleep(0.2)
9    # Simulate a fatal segmentation fault via SIGSEGV
10    os.kill(os.getpid(), signal.SIGTERM)
11 
12if __name__ == "__main__":
13    p = multiprocessing.Process(target=fragile_worker)
14    p.start()
15    p.join()
16 
17    print(f"[SUPERVISOR] Worker process exited with code: {p.exitcode}")
18    if p.exitcode != 0:
19        print("[SUPERVISOR] Detected worker failure! Spawning healthy replacement worker...")

4. Concurrency Decision Matrix

Use this systematic checklist when architecting Python systems:

Output

                             What is your bottleneck?
                                        │
                ┌───────────────────────┴───────────────────────┐
                ▼                                               ▼
           CPU-BOUND                                         I/O-BOUND
  (Math, Hashing, Compression,                      (Network, REST APIs, Disk,
      Image transformations)                                 Database)
                │                                               │
                ▼                                 How many concurrent connections?
        MULTIPROCESSING                                         │
      (ProcessPoolExecutor)                     ┌───────────────┴───────────────┐
                                                ▼                               ▼
                                          < 1,000 Tasks                  > 1,000 Tasks
                                          (Moderate I/O)                 (High-scale I/O)
                                                │                               │
                                                ▼                               ▼
                                           THREADING                         ASYNCIO
                                      (ThreadPoolExecutor)             (Event Loop / Tasks)

5. Architectural Summary Table

Criterion	Threading	Multiprocessing	Asyncio
Best For	Moderate I/O-bound tasks	Heavy CPU-bound computation	Massive concurrent I/O (sockets, web)
Concurrency Type	Preemptive multitasking	Preemptive parallel execution	Cooperative single-threaded concurrency
Hardware Utilization	1 CPU core at a time	All available CPU cores	1 CPU core
Data Sharing	Shared heap (use Locks)	IPC / Pipes / SharedMemory	Shared heap (single thread, no data race)
Fault Isolation	Poor (shared crash)	High (isolated processes)	Medium (uncaught exception bubbles)

Multiple Choice Questions

1.

What occurs at the operating system level during a process context switch that makes it significantly more expensive than a thread context switch? A. The computer must be rebooted. B. The OS must switch page table mappings in the Memory Management Unit (MMU) and invalidate the CPU Translation Lookaside Buffer (TLB). C. All disk drives are unmounted. D. The Global Interpreter Lock is uninstalled.

Answer: B

Explanation:Process context switching requires changing the active virtual memory address space, forcing the MMU page table base register to update and clearing cached memory translations in the CPU TLB cache.

2.

Why is multiprocessing preferred over threading for CPU-intensive mathematical simulations in Python? A. Multiprocessing does not require importing standard libraries. B. Each process runs its own CPython interpreter instance with a private GIL, allowing simultaneous execution across multiple CPU cores. C. Threads cannot execute loops. D. Multiprocessing bypasses operating system security.

Answer: B

Explanation:In CPython, the GIL limits bytecode execution to one thread at a time per interpreter. By spawning separate processes, each process has its own interpreter and GIL, enabling true parallel execution across cores.

3.

In an application utilizing multithreading, what happens if one worker thread encounters a segmentation fault inside a compiled C-extension? A. Only that specific thread exits; other threads continue running. B. The entire operating system process crashes immediately, terminating all threads. C. CPython catches the segmentation fault and turns it into a KeyError. D. The thread restarts automatically.

Answer: B

Explanation:Threads share the process's single address space. An unrecoverable low-level memory fault (like a segfault) corrupts the process image and causes the operating system kernel to terminate the entire process.

4.

When would threading (or asyncio) be preferred over multiprocessing for an I/O-bound web crawler? A. When you want to maximize CPU cache thrashing. B. Because threads have lower memory overhead and avoid the serialization (pickling) costs associated with inter-process communication. C. Because processes cannot establish internet connections. D. Because threads run faster on GPUs.

Answer: B

Explanation:Spawning hundreds of processes consumes gigabytes of memory and incurs heavy IPC serialization overhead. Threads and asynchronous coroutines are much lighter and ideal for waiting on I/O.

5.

How is data transferred between separate processes in Python's multiprocessing module by default? A. Direct raw pointer dereferencing in memory. B. Data is serialized into byte streams using pickle and transferred via inter-process communication (IPC) pipes or queues. C. Data is written to optical discs. D. Through global environment variables.

Answer: B

Explanation:Because processes have isolated virtual memory spaces, Python serializes data objects using the pickle protocol and sends the bytes through operating system pipes or sockets.

Next Lesson

Shared Memory & Queues

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Multiprocessing Basics	Shared Memory & Queues

Practice Quiz

Test your understanding of this lesson with 5 questions. Each question has one correct answer.

Previous Next

PrevNext