Python provides two primary approaches for concurrency: multithreading and multiprocessing. Although both aim to run tasks in parallel, they differ fundamentally in how they utilize system resources, especially CPU and memory.
Understanding Multithreading
Multithreading allows multiple threads to run within the same process. Threads share the same memory space, which makes communication between them fast and efficient. This is particularly useful for tasks that are I/O-bound, such as reading files, making network requests, or waiting for database responses.In Python, multithreading is implemented using the built-in threading module.
import threading
import time
def task(name):
print(f"Thread {name} starting")
time.sleep(2)
print(f"Thread {name} finished")
t1 = threading.Thread(target=task, args=("A",))
t2 = threading.Thread(target=task, args=("B",))
t1.start()
t2.start()
t1.join()
t2.join()
print("All threads completed")
Output:
Thread A starting
Thread B starting
Thread A finished
Thread B finished
All threads completed
The Global Interpreter Lock (GIL)
One of the most important concepts when discussing multithreading in Python is the Global Interpreter Lock (GIL). The GIL ensures that only one thread executes Python bytecode at a time, even on multi-core systems.This means that for CPU-bound tasks (tasks that require heavy computation), multithreading does not provide true parallelism. However, for I/O-bound tasks, threads are still highly effective because they release the GIL while waiting for external operations.
Threads are faster to create and communicate efficiently because they share memory. However, this shared memory can lead to issues like race conditions and requires synchronization mechanisms such as locks.
Understanding Multiprocessing
Multiprocessing involves running multiple processes, each with its own memory space and Python interpreter. Unlike threads, processes do not share memory, which eliminates the limitations imposed by the GIL.Python provides the multiprocessing module to create and manage processes.
from multiprocessing import Process
import time
def task(name):
print(f"Process {name} starting")
time.sleep(2)
print(f"Process {name} finished")
if __name__ == "__main__":
p1 = Process(target=task, args=("A",))
p2 = Process(target=task, args=("B",))
p1.start()
p2.start()
p1.join()
p2.join()
print("All processes completed")
Output
Process A starting
Process B starting
Process A finished
Process B finished
All processes completed
CPU-bound vs I/O-bound Tasks
Choosing between multithreading and multiprocessing depends largely on the type of task.I/O-bound tasks involve waiting for external operations such as file reading, network calls, or database queries. These tasks benefit from multithreading because threads can switch while waiting.
CPU-bound tasks involve heavy computations like mathematical calculations, image processing, or machine learning training. These tasks benefit from multiprocessing because they can fully utilize multiple CPU cores. Example: CPU-bound Task Comparison Let's consider a CPU-intensive computation:
def compute():
total = 0
for i in range(10_000_000):
total += i
return total
Inter-Process Communication
Since processes do not share memory, communication between them requires special mechanisms such as queues, pipes, or shared memory constructs.from multiprocessing import Process, Queue
def worker(q):
q.put("Hello from process")
q = Queue()
if __name__ == '__main__':
p = Process(target=worker, args=(q,))
p.start()
p.join()
print(q.get())
In real-world applications, multithreading is commonly used in web servers, where multiple requests need to be handled simultaneously. Multiprocessing is often used in data processing pipelines, scientific computing, and machine learning tasks where heavy computations are involved.
Join the discussion