13.3 Multiprocessing vs. Multithreading (in Python)

When it comes to parallelism and concurrency in Python, two key concepts come into play: multithreading and multiprocessing. While both allow for executing multiple tasks simultaneously, they do so in different ways and are suited to different kinds of tasks.

13.3.1 Multithreading

Multithreading refers to the concurrent execution of multiple threads (lightweight sub-processes) within a single process. Threads share the same memory space and resources, which allows for efficient communication but also increases the risk of race conditions.

Key Characteristics of Multithreading:

• Concurrency: Threads run concurrently, which means they share the same resources, including memory.
• Lightweight: Threads are smaller and faster to create and manage compared to processes.
• I/O-bound tasks: Multithreading is ideal for tasks that involve waiting (e.g., network operations, file I/O) since threads can perform other tasks while waiting for input/output.
• Global Interpreter Lock (GIL): In Python, the GIL limits the execution of threads, allowing only one thread to execute Python bytecode at a time, which can be a bottleneck for CPU-bound tasks.

When to Use Multithreading:

• When your tasks are I/O-bound (e.g., reading from disk, network requests).
• When threads need to share data and resources without much overhead.
• When fast context switching and low memory overhead are essential.

13.3.2 Multiprocessing

Multiprocessing involves running multiple processes simultaneously, with each process having its own memory space and resources. Unlike threads, processes do not share memory, and communication between processes requires more overhead (e.g., through inter-process communication (IPC)).

Key Characteristics of Multiprocessing:

• Parallelism: True parallelism is achieved by running multiple processes across multiple CPU cores.
• Independent memory space: Each process has its own memory space, so there is no need for synchronization primitives like locks.
• CPU-bound tasks: Multiprocessing is ideal for tasks that require significant computation (CPU-bound) because each process can run on a separate core, bypassing the GIL.
• More resource-intensive: Processes are heavier than threads, with higher overhead in memory and process creation.

When to Use Multiprocessing:

• When your tasks are CPU-bound (e.g., complex computations, image processing).
• When you need true parallelism on multi-core systems.
• When tasks are independent of each other and do not need to share memory.

13.3.3 The Global Interpreter Lock (GIL)

The Global Interpreter Lock (GIL) is a mechanism used in CPython (the standard Python interpreter) to ensure that only one thread executes Python bytecode at a time. This simplifies memory management but limits the true parallel execution of threads in CPU-bound tasks.

Impact of the GIL on Multithreading:

• For I/O-bound tasks, the GIL is not much of an issue because threads spend a lot of time waiting for external input/output, allowing other threads to execute while one thread is waiting.
• For CPU-bound tasks, the GIL can be a major bottleneck because it prevents multiple threads from executing CPU-intensive operations in parallel.

Bypassing the GIL with Multiprocessing:

• The GIL only affects multithreading, not multiprocessing. Since each process has its own Python interpreter and memory space, the GIL does not apply. This makes multiprocessing the go-to solution for CPU-bound tasks that require parallelism.

13.3.4 Comparison: Multithreading vs. Multiprocessing

13.3.5 Practical Example: Multithreading vs. Multiprocessing

Example 1: Multithreading for I/O-bound Tasks

In this example, we simulate downloading data from multiple URLs using multithreading. Since network I/O is the bottleneck here, multithreading is ideal.

import threading
import time

def download_data(url):
    print(f"Starting download from {url}")
    time.sleep(2)  # Simulate network delay
    print(f"Finished downloading from {url}")

# List of URLs to download from
urls = ['http://example1.com', 'http://example2.com', 'http://example3.com']

# Create and start threads for downloading
threads = []
for url in urls:
    thread = threading.Thread(target=download_data, args=(url,))
    threads.append(thread)
    thread.start()

# Wait for all threads to finish
for thread in threads:
    thread.join()

print("All downloads completed.")

Output:

Starting download from http://example1.com
Starting download from http://example2.com
Starting download from http://example3.com
Finished downloading from http://example1.com
Finished downloading from http://example2.com
Finished downloading from http://example3.com
All downloads completed.

In this example:

• Each thread handles a simulated download, and since network I/O is the bottleneck, threads can run concurrently while waiting for the I/O operations to complete.

Example 2: Multiprocessing for CPU-bound Tasks

In this example, we compute the squares of numbers using multiprocessing. Since the task is CPU-bound, multiprocessing allows us to take advantage of multiple CPU cores.

import multiprocessing
import time

def compute_square(n):
    time.sleep(1)  # Simulate computation delay
    print(f"Square of {n}: {n * n}")

# List of numbers to compute the square of
numbers = [1, 2, 3, 4, 5]

# Create a pool of processes
with multiprocessing.Pool() as pool:
    pool.map(compute_square, numbers)

print("All computations completed.")

Output:

Square of 1: 1
Square of 2: 4
Square of 3: 9
Square of 4: 16
Square of 5: 25
All computations completed.

In this example:

• Each process computes the square of a number independently. Multiprocessing takes advantage of multiple CPU cores to run these computations in parallel, making it ideal for CPU-bound tasks.

13.3.6 Choosing Between Multithreading and Multiprocessing

Use Multithreading When:

• Your program is I/O-bound (e.g., waiting for input/output operations such as file I/O, network requests, database access).
• You need lightweight concurrency with minimal memory overhead.
• Threads need to share data or resources easily without much complexity.

Use Multiprocessing When:

• Your program is CPU-bound and requires true parallelism.
• You want to bypass the GIL and leverage multiple CPU cores for parallel execution.
• Tasks are independent of each other, and communication overhead is not a concern.
• Fault isolation is important (i.e., you want a process crash to not affect other processes).

13.3.7 Summary

• Multithreading: Ideal for I/O-bound tasks where the program spends time waiting for input/output operations to complete. Threads share the same memory space, and context switching is fast, but the Global Interpreter Lock (GIL) limits true parallelism in CPU-bound tasks.
• Multiprocessing: Best suited for CPU-bound tasks where heavy computation is involved. Each process runs in its own memory space, and true parallelism is achieved by running processes on multiple CPU cores, bypassing the GIL.

Key Differences:

• Concurrency vs. Parallelism: Multithreading provides concurrency within a single process, while multiprocessing provides true parallelism across multiple processes.
• Shared Memory vs. Isolated Memory: Threads share memory, making data sharing easy but requiring synchronization. Processes have isolated memory, making them safer but requiring inter-process communication (IPC) for data sharing.
• Performance: Multithreading is generally faster and more memory-efficient for I/O-bound tasks, while multiprocessing is better for CPU-bound tasks.

By understanding the differences between multithreading and multiprocessing, you can choose the right approach for optimizing the performance of your Python programs based on the nature of your tasks.