Python - Concurrency and Parallelism: Threading, Multiprocessing

Concurrency and Parallelism: Threading, Multiprocessing in Python

Introduction 

Python provides powerful modules and tools to support concurrent and parallel programming. These include threading and multiprocessing modules, both of which enable the execution of tasks in an efficient and scalable manner. Understanding the differences between concurrency and parallelism, and the tools Python provides, helps developers build responsive, high-performance applications.

Concurrency vs Parallelism

Definition of Concurrency

Concurrency refers to the ability of a program to deal with many tasks at once by managing multiple tasks over the same period of time. These tasks may not execute simultaneously but can be interleaved on a single CPU core.

Definition of Parallelism

Parallelism, on the other hand, means executing multiple tasks at the same time, typically on multiple processors or cores. This approach is used to achieve true simultaneous execution.

Comparison Table

Python Threading

What is Threading?

Threading allows the execution of multiple threads in a single process space. It's best suited for I/O-bound tasks like network operations or file I/O because Python’s Global Interpreter Lock (GIL) can prevent multiple threads from executing Python bytecode simultaneously.

Creating Threads with the threading Module

import threading

def print_numbers():
    for i in range(5):
        print(f"Number: {i}")

t1 = threading.Thread(target=print_numbers)
t1.start()
t1.join()

Thread Lifecycle

• New
• Runnable
• Running
• Waiting
• Terminated

Using Thread Class with Subclassing

Example of Subclassing Thread

import threading

class MyThread(threading.Thread):
    def run(self):
        for i in range(5):
            print(f"MyThread {i}")

thread = MyThread()
thread.start()
thread.join()

Thread Synchronization

Why Synchronization is Needed

Multiple threads accessing shared resources can lead to race conditions. Synchronization prevents such issues by allowing only one thread to access a resource at a time.

Using Lock

import threading

lock = threading.Lock()
shared_resource = 0

def increment():
    global shared_resource
    with lock:
        for _ in range(1000):
            shared_resource += 1

threads = [threading.Thread(target=increment) for _ in range(10)]
for t in threads:
    t.start()
for t in threads:
    t.join()

print(shared_resource)

Thread-safe Queues

Using queue.Queue

import threading
import queue

q = queue.Queue()

def producer():
    for i in range(5):
        q.put(i)

def consumer():
    while not q.empty():
        print(f"Consumed {q.get()}")

t1 = threading.Thread(target=producer)
t2 = threading.Thread(target=consumer)

t1.start()
t1.join()
t2.start()
t2.join()

Daemon Threads

What Are Daemon Threads?

Daemon threads run in the background and are killed once the main program exits. They are useful for background tasks that should not block program termination.

Example

import threading
import time

def background():
    while True:
        print("Running in background...")
        time.sleep(1)

daemon_thread = threading.Thread(target=background)
daemon_thread.daemon = True
daemon_thread.start()

time.sleep(3)
print("Main program exits")

Python Multiprocessing

What is Multiprocessing?

The multiprocessing module enables parallelism by creating separate processes that execute independently. Unlike threads, processes have their own memory space and bypass the GIL, making multiprocessing ideal for CPU-bound tasks.

Simple Multiprocessing Example

from multiprocessing import Process

def worker():
    for i in range(5):
        print(f"Worker {i}")

p = Process(target=worker)
p.start()
p.join()

Using multiprocessing.Pool

Pool for Task Parallelism

A Pool of workers allows multiple tasks to be distributed across available processors.

Example

from multiprocessing import Pool

def square(x):
    return x * x

with Pool(4) as p:
    results = p.map(square, [1, 2, 3, 4, 5])
    print(results)

Inter-Process Communication (IPC)

Using Queue

from multiprocessing import Process, Queue

def worker(q):
    q.put('Hello from child process!')

q = Queue()
p = Process(target=worker, args=(q,))
p.start()
print(q.get())
p.join()

Using Pipe

from multiprocessing import Pipe, Process

def child(conn):
    conn.send("Data from child")
    conn.close()

parent_conn, child_conn = Pipe()
p = Process(target=child, args=(child_conn,))
p.start()
print(parent_conn.recv())
p.join()

Shared Memory

Using multiprocessing.Value and multiprocessing.Array

from multiprocessing import Process, Value

def increment(shared_val):
    for _ in range(1000):
        shared_val.value += 1

val = Value('i', 0)
processes = [Process(target=increment, args=(val,)) for _ in range(5)]

for p in processes:
    p.start()
for p in processes:
    p.join()

print(val.value)

Synchronization in Multiprocessing

Using Lock

from multiprocessing import Process, Lock, Value

def safe_increment(val, lock):
    for _ in range(1000):
        with lock:
            val.value += 1

val = Value('i', 0)
lock = Lock()
processes = [Process(target=safe_increment, args=(val, lock)) for _ in range(5)]

for p in processes:
    p.start()
for p in processes:
    p.join()

print(val.value)

Performance Considerations

Threading vs Multiprocessing

• Threading: Ideal for I/O-bound operations (file/network I/O).
• Multiprocessing: Best for CPU-bound operations (computations).

CPU-bound Task Example

from multiprocessing import Pool
import math

def compute():
    for _ in range(1000000):
        math.sqrt(12345)

with Pool(4) as p:
    p.map(lambda x: compute(), range(4))

Combining Threading and Multiprocessing

Example: Multiprocessing with Threaded Workers

Sometimes a process may launch threads internally to improve performance in a hybrid manner.

from multiprocessing import Process
import threading

def thread_task():
    print("Running in thread")

def process_task():
    threads = [threading.Thread(target=thread_task) for _ in range(5)]
    for t in threads:
        t.start()
    for t in threads:
        t.join()

p = Process(target=process_task)
p.start()
p.join()

Common Pitfalls and Best Practices

Do Not Share State in Threads Unprotected

Always use Lock, Semaphore, or other synchronization primitives to avoid race conditions.

Avoid Forking Threads

Never fork a process from within a thread as it can lead to unpredictable behavior.

Use multiprocessing.set_start_method()

Especially on Windows and macOS, set the start method explicitly.

import multiprocessing
multiprocessing.set_start_method("spawn")

Don’t Overuse Processes

Spawning too many processes can lead to high memory usage and context-switching overhead.

Debugging and Logging in Concurrency

Using Logging Instead of Print

import logging
import threading

logging.basicConfig(level=logging.DEBUG, format='%(threadName)s: %(message)s')

def task():
    logging.debug('Running task')

t = threading.Thread(target=task)
t.start()
t.join()

Concurrency and parallelism are critical concepts in modern software development. Python provides robust tools to implement both, via the threading and multiprocessing modules. Threading is best suited for I/O-bound tasks, whereas multiprocessing is ideal for CPU-intensive operations. Developers must carefully choose the appropriate approach based on task requirements, taking care to manage shared resources using synchronization primitives.

Understanding these tools can help developers write scalable, performant Python applications that leverage the power of modern multi-core systems efficiently. Whether you're building data pipelines, web scrapers, or computational engines, threading and multiprocessing provide essential building blocks for effective parallel programming in Python.