Multithreading and Multiprocessing

Concurrent programming allows a program to make progress on multiple tasks seemingly at the same time, significantly improving responsiveness and utilizing modern multi-core processors. The two primary paradigms for achieving concurrency are Multithreading and Multiprocessing.

Multithreading
Multithreading involves running multiple threads within a single process. A thread is the smallest unit of execution that can be scheduled by an operating system. All threads within the same process share the same memory space, global variables, and resources (like open files). This shared memory makes data exchange between threads very efficient but also introduces challenges like race conditions, where multiple threads try to access or modify shared data simultaneously, leading to unpredictable results. Synchronization mechanisms (e.g., locks, semaphores, condition variables) are crucial to manage shared resources and prevent data corruption.

In Python, multithreading is limited by the Global Interpreter Lock (GIL). The GIL ensures that only one thread can execute Python bytecode at a time, even on multi-core processors. This means Python multithreading doesn't achieve true parallel execution for CPU-bound tasks (tasks that spend most of their time doing calculations). However, for I/O-bound tasks (tasks that spend most of their time waiting for external operations like network requests, file I/O, or user input), multithreading can still be beneficial because the GIL is released during these waiting periods, allowing other threads to run.

Multiprocessing
Multiprocessing involves running multiple independent processes. Each process has its own dedicated memory space, global variables, and resources. They do not share memory directly, which eliminates many of the synchronization issues associated with shared data in multithreading. Communication between processes typically requires explicit Inter-Process Communication (IPC) mechanisms such as pipes, queues, or shared memory (managed carefully).

Multiprocessing allows for true parallel execution on multi-core processors because each process runs independently with its own Python interpreter instance. This makes it ideal for CPU-bound tasks, as it can effectively utilize all available CPU cores. The overhead of creating a new process is generally higher than creating a new thread, and IPC can be more complex than direct memory access in threading, but the benefits for CPU-bound parallelism often outweigh these costs.

Key Differences Summarized:
- Memory Space: Threads share memory; processes have separate memory spaces.
- GIL (Python): Multithreading is affected by GIL (no true CPU parallelism); Multiprocessing bypasses GIL (true CPU parallelism).
- Overhead: Threads have lower creation/context switching overhead; Processes have higher overhead.
- Data Sharing: Easier (but more dangerous) in threading; Requires explicit IPC in multiprocessing.
- Robustness: A crash in one thread can affect the whole process; A crash in one process generally doesn't affect others.
- Best Use Cases: Multithreading for I/O-bound tasks; Multiprocessing for CPU-bound tasks.

import threading
import multiprocessing
import time
import os

def io_bound_task(name):
    """Simulates an I/O-bound task by sleeping"""
    print(f"Thread {name}: Starting I/O task... (PID: {os.getpid()})")
    time.sleep(2)   Simulate network request, file read, etc.
    print(f"Thread {name}: Finished I/O task.")

def cpu_bound_task(name, num):
    """Simulates a CPU-bound task by performing heavy calculations"""
    print(f"Process {name}: Starting CPU task... (PID: {os.getpid()})")
    result = 0
    for i in range(num):
        result += i - i
    print(f"Process {name}: Finished CPU task. Result sum up to {num} is {result % 1000000} (partial display).")

if __name__ == "__main__":
    print("\n--- Demonstrating Multithreading (I/O-bound) ---")
    start_time_threads = time.perf_counter()

    threads = []
    for i in range(3):
        t = threading.Thread(target=io_bound_task, args=(f"Thread-{i}",))
        threads.append(t)
        t.start()

    for t in threads:
        t.join()  Wait for all threads to complete

    end_time_threads = time.perf_counter()
    print(f"All I/O tasks completed in {end_time_threads - start_time_threads:.2f} seconds using multithreading.")
    print("Note: For I/O-bound tasks, multithreading can be significantly faster than sequential execution because threads release the GIL while waiting for I/O.\n")

    print("--- Demonstrating Multiprocessing (CPU-bound) ---")
    start_time_processes = time.perf_counter()

    processes = []
    num_calculations = 50_000_000  A moderately heavy calculation
    for i in range(3):
        p = multiprocessing.Process(target=cpu_bound_task, args=(f"Process-{i}", num_calculations))
        processes.append(p)
        p.start()

    for p in processes:
        p.join()  Wait for all processes to complete

    end_time_processes = time.perf_counter()
    print(f"All CPU tasks completed in {end_time_processes - start_time_processes:.2f} seconds using multiprocessing.")
    print("Note: For CPU-bound tasks, multiprocessing leverages multiple CPU cores for true parallelism, offering significant speedup over sequential or multithreaded (in Python) execution.")