Python Multithreading Guide: From Beginner to Pro

1. Introduction

Why use multithreading in Python

• Processing large amounts of data: Retrieving data from databases or handling a large number of files can reduce processing time through parallelization.
• Improving I/O efficiency: In programs with heavy I/O, such as file reads/writes or network communication, you can minimize waiting time.
• Real-time requirements: In game or user interface programming, where multiple tasks must run simultaneously, multithreading becomes essential.

Benefits and challenges of multithreading

Advantages

1. Increased processing speed: Multiple threads running concurrently can distribute tasks more efficiently.
2. Effective use of resources: Even if some threads are idle, others can utilize CPU resources.

Challenges

1. Global Interpreter Lock (GIL) limitations: In Python, the presence of the GIL can limit the effectiveness of multithreading.
2. Debugging complexity: Issues like race conditions and deadlocks are more likely to occur, which can make debugging time-consuming.

Purpose of this article

2. Comparison of Multithreading and Multiprocessing

Basic differences between threads and processes

What is a thread

• Characteristics:
• Share the same memory space
• Lightweight and fast to start
• Easy data sharing

What is a process

• Characteristics:
• Has an independent memory space
• More heavyweight and slower to start
• Additional mechanisms are required for data sharing

Impact of the GIL (Global Interpreter Lock) in Python

• Cases that are more affected by the GIL:
• CPU-intensive computations (e.g., numerical calculations or image processing)
• Cases that are less affected by the GIL:
• I/O-bound workloads (e.g., network communication, file operations)

Choosing between multithreading and multiprocessing

When to choose multithreading

• Use cases:
• Programs with a lot of I/O operations
• When you need to run lightweight tasks in parallel
• Examples: Web scraping, concurrent file downloads

When to choose multiprocessing

• Use cases:
• CPU-intensive computations
• When you want to avoid the GIL’s limitations
• Examples: Training machine learning models, image processing

Simple comparison examples in Python

Multithreading example

import threading
import time

def task(name):
    print(f"{name} started")
    time.sleep(2)
    print(f"{name} finished")

threads = []
for i in range(3):
    thread = threading.Thread(target=task, args=(f"Thread {i+1}",))
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

print("All threads finished")

Multiprocessing example

from multiprocessing import Process
import time

def task(name):
    print(f"{name} started")
    time.sleep(2)
    print(f"{name} finished")

processes = []
for i in range(3):
    process = Process(target=task, args=(f"Process {i+1}",))
    processes.append(process)
    process.start()

for process in processes:
    process.join()

print("All processes finished")

Conclusion

Ad

3. Basic Concepts of Threads and Processes

Basic Concepts of Threads

Role of Threads

• Characteristics:
• A lightweight unit that runs within a process.
• Because they share memory space, data exchange is fast.
• Synchronization and race-condition control between threads are required.

Advantages and Challenges of Threads

• Advantages:
• High memory efficiency.
• Lightweight, with fast startup and switching.
• Challenges:
• There is a risk of data races and deadlocks on shared data.
• In Python, threads are affected by the GIL, so they are not suitable for CPU-bound tasks.

Basic Concepts of Processes

Role of Processes

• Characteristics:
• Uses a completely independent memory space.
• High security and stability.
• If inter-process communication (IPC) is needed, it becomes a bit more complex.

Advantages and Challenges of Processes

• Advantages:
• Not affected by the GIL, so ideal for CPU-bound workloads.
• Because processes are independent, they offer higher stability.
• Challenges:
• Starting and switching processes incurs overhead.
• Increases memory usage.

Comparison of Threads and Processes

How the Global Interpreter Lock (GIL) Works

• Advantages of the GIL:
• Prevents data races between threads and provides thread safety.
• Disadvantages of the GIL:
• For CPU-bound tasks, multithreading performance is limited.

Criteria for Choosing Between Threads and Processes

• When to Choose Threads:
• Most of the work spends time waiting for I/O (e.g., network communication).
• You want to keep memory usage low.
• When to Choose Processes:
• CPU-intensive workloads (e.g., numerical computations).
• You want to efficiently utilize multiple cores.

4. Implementing Multithreading in Python

Basic Usage of the threading Module

Creating and Running Threads

import threading
import time

def print_message(message):
    print(f"Start: {message}")
    time.sleep(2)
    print(f"End: {message}")

## Create threads
thread1 = threading.Thread(target=print_message, args=("Thread 1",))
thread2 = threading.Thread(target=print_message, args=("Thread 2",))

## Start threads
thread1.start()
thread2.start()

## Wait for threads to finish
thread1.join()
thread2.join()

print("All threads finished")

Explanation of the Output

Implementing Threads Using a Class

import threading
import time

class MyThread(threading.Thread):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        print(f"{self.name} started")
        time.sleep(2)
        print(f"{self.name} finished")

## Create threads
thread1 = MyThread("Thread 1")
thread2 = MyThread("Thread 2")

## Start threads
thread1.start()
thread2.start()

## Wait for threads to finish
thread1.join()
thread2.join()

print("All threads finished")

Explanation of the Output

Thread Synchronization and Locks

Example Using a Lock

import threading

lock = threading.Lock()
shared_resource = 0

def increment():
    global shared_resource
    with lock:  ## Acquire lock
        local_copy = shared_resource
        local_copy += 1
        shared_resource = local_copy

threads = []
for i in range(5):
    thread = threading.Thread(target=increment)
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

print(f"Final value of shared resource: {shared_resource}")

Explanation of the Output

Thread Timeouts and Daemon Threads

Thread Timeouts

thread.join(timeout=5)

Daemon Threads

thread = threading.Thread(target=print_message)
thread.daemon = True
thread.start()

Practical Examples of Multithreading

import threading
import time

def download_file(file_name):
    print(f"Starting download of {file_name}")
    time.sleep(2)  ## Simulate download
    print(f"Finished downloading {file_name}")

files = ["file1", "file2", "file3"]

threads = []
for file in files:
    thread = threading.Thread(target=download_file, args=(file,))
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

print("All files downloaded")

Conclusion

Ad

5. Multithreading Use Cases

1. Improving Web Scraping Efficiency

Sample code

import threading
import requests
import time

urls = [
    "https://example.com/page1",
    "https://example.com/page2",
    "https://example.com/page3"
]

def fetch_url(url):
    print(f"Starting fetch for {url}")
    response = requests.get(url)
    print(f"Fetch complete for {url}: status code {response.status_code}")

threads = []
start_time = time.time()

for url in urls:
    thread = threading.Thread(target=fetch_url, args=(url,))
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

end_time = time.time()
print(f"Processing time: {end_time - start_time:.2f} seconds")

Explanation of the results

2. Concurrent File Downloads

Sample code

import threading
import time

def download_file(file_name):
    print(f"Starting download of {file_name}")
    time.sleep(2)  ## Simulate download
    print(f"Download complete for {file_name}")

files = ["file1.zip", "file2.zip", "file3.zip"]

threads = []
for file in files:
    thread = threading.Thread(target=download_file, args=(file,))
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

print("All downloads complete")

Explanation of the results

3. Parallel Execution of Database Queries

Sample code

import threading
import time

def query_database(query):
    print(f"Running query: {query}")
    time.sleep(2)  ## Simulate query execution
    print(f"Query complete: {query}")

queries = ["SELECT * FROM users", "SELECT * FROM orders", "SELECT * FROM products"]

threads = []
for query in queries:
    thread = threading.Thread(target=query_database, args=(query,))
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

print("All queries completed")

Explanation of the results

4. Parallelizing Video Processing

Sample code

import threading
import time

def process_frame(frame_number):
    print(f"Starting processing for frame {frame_number}")
    time.sleep(1)  ## Simulate processing
    print(f"Processing complete for frame {frame_number}")

frame_numbers = range(1, 6)

threads = []
for frame in frame_numbers:
    thread = threading.Thread(target=process_frame, args=(frame,))
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

print("All frames processed")

Explanation of the results

Conclusion

6. Cautions and Best Practices for Using Multithreading

Cautions

1. Impact of the Global Interpreter Lock (GIL)

• Cases affected:
• Heavy computational workloads
• Algorithms that require high CPU usage
• Mitigations:
• Use the multiprocessing module to parallelize with multiple processes.
• Use C extension modules or optimized libraries like NumPy to avoid the GIL.

2. Deadlocks

• Example: Thread A holds resource X and waits for resource Y, while Thread B holds resource Y and waits for resource X.
• Mitigations:
• Always acquire resources in a consistent order.
• Use the RLock (reentrant lock) from the threading module to prevent deadlocks.

Sample code (deadlock avoidance)

import threading

lock1 = threading.Lock()
lock2 = threading.Lock()

def task1():
    with lock1:
        print("Task1 acquired lock1")
        with lock2:
            print("Task1 acquired lock2")

def task2():
    with lock2:
        print("Task2 acquired lock2")
        with lock1:
            print("Task2 acquired lock1")

thread1 = threading.Thread(target=task1)
thread2 = threading.Thread(target=task2)

thread1.start()
thread2.start()

thread1.join()
thread2.join()
print("Both tasks completed")

3. Race conditions

• Example: If two threads try to increment a counter variable at the same time, the counter may not increase as expected.
• Mitigations:
• Use the Lock from the threading module to synchronize access to shared data.
• Minimize data sharing between threads.

Sample code (avoidance using locks)

import threading

lock = threading.Lock()
counter = 0

def increment():
    global counter
    with lock:
        local_copy = counter
        local_copy += 1
        counter = local_copy

threads = [threading.Thread(target=increment) for _ in range(100)]

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

print(f"Counter value: {counter}")

Best practices

1. Setting the appropriate number of threads

• When setting the number of threads, consider the number of CPU cores and I/O wait times.
• Recommendation: For I/O-bound tasks, it’s usually fine to increase the thread count, but for CPU-intensive tasks it’s common to limit threads to the number of cores.

2. Debugging and logging

• Multithreaded programs are harder to debug, so proper logging is important.
• Recommendation: Use Python’s logging module to record logs per thread.

Sample code (logging)

import threading
import logging

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

def task():
    logging.debug("Task running")

threads = [threading.Thread(target=task) for _ in range(5)]

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

logging.debug("All tasks completed")

3. Using high-level libraries

Sample code (ThreadPoolExecutor)

from concurrent.futures import ThreadPoolExecutor

def task(name):
    print(f"{name} running")

with ThreadPoolExecutor(max_workers=3) as executor:
    executor.map(task, ["Task 1", "Task 2", "Task 3"])

Conclusion

7. Comparison of Multithreading and Multiprocessing

Basic Differences Between Multithreading and Multiprocessing

Detailed Explanation

• Multithreading: Because multiple threads run within the same process, it’s lightweight and data sharing is easy. However, in Python, the GIL can limit performance for CPU-intensive tasks.
• Multiprocessing: Since processes do not share memory space, it’s not affected by the GIL and can fully utilize multiple CPU cores. However, if inter-process communication (IPC) is required, the implementation can be somewhat more complex.

When to Choose Multithreading

• Examples:
• Web scraping
• File operations (read/write)
• Network communication (asynchronous operations)
• Reason: Multithreading can efficiently utilize I/O waiting time, increasing parallelism. Also, because threads share the same memory space, exchanging data is easy.

Code example: I/O-bound tasks

import threading
import time

def file_operation(file_name):
    print(f"Start processing {file_name}")
    time.sleep(2)  ## Simulate a file operation
    print(f"Finished processing {file_name}")

files = ["file1.txt", "file2.txt", "file3.txt"]

threads = []
for file in files:
    thread = threading.Thread(target=file_operation, args=(file,))
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

print("All file operations are complete")

When to Choose Multiprocessing

• Examples:
• Large-scale data processing
• Training machine learning models
• Image processing and numerical computations
• Reason: You can avoid the GIL and fully utilize multiple CPU cores to achieve high computational performance. However, sharing data between processes can be cumbersome.

Code example: CPU-intensive tasks

from multiprocessing import Process
import time

def compute_heavy_task(task_id):
    print(f"Running task {task_id}")
    time.sleep(3)  ## Simulate a computation
    print(f"Task {task_id} complete")

tasks = ["Computation 1", "Computation 2", "Computation 3"]

processes = []
for task in tasks:
    process = Process(target=compute_heavy_task, args=(task,))
    processes.append(process)
    process.start()

for process in processes:
    process.join()

print("All computation tasks are complete")

Combining Both

Criteria for Choosing Between Multithreading and Multiprocessing

1. Nature of the task:

• If there’s a lot of I/O waiting: Multithreading
• For compute-heavy tasks: Multiprocessing

1. Resource constraints:

• If you want to minimize memory usage: Multithreading
• If you want to fully utilize CPU cores: Multiprocessing

1. Code complexity:

• If you want to share data easily: Multithreading
• If you can handle inter-process communication: Multiprocessing

8. Summary and FAQ

Key takeaways

1. Characteristics of multithreading

• Well-suited for reducing I/O wait time and makes sharing data easy.
• Affected by the GIL, so not suitable for CPU-bound tasks.

1. Characteristics of multiprocessing

• Not constrained by the GIL and performs well for CPU-intensive workloads.
• Uses separate memory spaces, so inter-process communication may be required.

1. Choosing the right approach is key

• Use multithreading for I/O-bound tasks and multiprocessing for CPU-bound tasks.
• Combining both when appropriate can yield optimal performance.

FAQ (Frequently Asked Questions)

Q1: When using multithreading, how many threads should I use?

• I/O-bound tasks: You can use many threads without problems. Specifically, it’s common to match the number of threads to the number of tasks you want to process concurrently.
• CPU-bound tasks: Keep the number of threads at or below the number of physical cores. Too many threads can lead to performance degradation due to the GIL.

Q2: Is there a way to completely avoid the constraints of the GIL?

• Use multiprocessing:multiprocessing allows you to avoid the GIL by performing process-level parallelism.
• Use external libraries: Libraries implemented in C, such as NumPy and Pandas, can temporarily release the GIL and operate very efficiently.

Q3: How do multithreading and asynchronous programming (asyncio) differ?

• Multithreading: Uses threads to execute tasks in parallel. Because threads share resources, synchronization may be necessary.
• Asynchronous programming: Uses asyncio to switch between tasks within an event loop. Runs within a single thread, avoiding thread contention and locking issues. It’s specialized for I/O waiting, so it’s lighter-weight than threads.

Q4: What are the benefits of using a thread pool in Python?

from concurrent.futures import ThreadPoolExecutor

def task(name):
    print(f"{name} is running")

with ThreadPoolExecutor(max_workers=5) as executor:
    executor.map(task, ["Task 1", "Task 2", "Task 3", "Task 4", "Task 5"])

Q5: Does using multithreading increase memory consumption?

Conclusion

Ad