Topic 3: Multi-threading and Multi-processing


At the heart of concurrent programming lies two powerful concepts: multi-threading and multi-processing. Both of these techniques allow a program to perform multiple tasks simultaneously, but they achieve this in different ways and come with their own set of benefits and trade-offs.


Definition: Multi-threading is the concurrent execution of more than one sequential set of instructions, or thread. These threads live within a process and share the same memory space.


  • Shared Memory: Threads share the same memory space, which can lead to easier data sharing between threads.
  • Low Overhead: Thread creation, destruction, and context switching often have lower overhead than processes.


  • GIL in CPython: The Global Interpreter Lock (GIL) in CPython (the most widely used Python interpreter) means that only one thread can execute Python code at a time.
  • Concurrency Issues: Due to shared memory, threads can interfere with each other leading to race conditions, deadlocks, etc.

Python Example:

import threading def print_numbers(): for i in range(5): print(i) def print_letters(): for letter in 'abcde': print(letter) # Creating threads t1 = threading.Thread(target=print_numbers) t2 = threading.Thread(target=print_letters) # Starting threads t1.start() t2.start() # Waiting for both threads to finish t1.join() t2.join()


Definition: Multi-processing involves using multiple processes, each with its own memory space and Python interpreter with its own GIL. Therefore, it’s truly concurrent and can fully utilize multiple CPU cores.


  • True Parallelism: Processes run independently and can run code in true parallel on multiple cores.
  • Memory Isolation: One process can’t affect another (e.g., no race conditions between processes).


  • Higher Overhead: More overhead than threads due to inter-process communication (IPC), and processes creation/destruction.
  • Data Sharing Complexity: Requires techniques like pipes or queues to share data between processes.

Python Example:

from multiprocessing import Process def print_numbers(): for i in range(5): print(i) def print_letters(): for letter in 'abcde': print(letter) # Creating processes p1 = Process(target=print_numbers) p2 = Process(target=print_letters) # Starting processes p1.start() p2.start() # Waiting for both processes to finish p1.join() p2.join()

Key Differences

  1. Concurrency: Multi-threading is well-suited for I/O-bound tasks (e.g., network communication), while multi-processing is designed for CPU-bound tasks (e.g., data processing).
  2. Memory: Threads share the same memory space; processes have separate memory.
  3. Safety: Threads can lead to race conditions and deadlocks. Processes are safer in this regard due to memory isolation.
  4. Performance: The GIL in CPython can limit the performance benefits of multi-threading, while multi-processing can utilize multiple CPU cores to their fullest extent.


Both multi-threading and multi-processing are essential tools for achieving concurrent execution in Python. The choice between them should be based on the specific task at hand. Understanding the intricacies, benefits, and trade-offs of each is crucial for writing efficient and effective Python programs.