Home / Python / Day 10: Advanced Python / Multithreading in Python

Multithreading in Python

Multithreading allows a program to run multiple tasks concurrently, which is especially useful for I/O-bound operations like file or network access.

What is Multithreading?

A thread is a separate flow of execution within a program. Multithreading lets multiple threads run "concurrently," which is useful when a program spends time waiting (I/O-bound tasks) — such as downloading files or reading from disk — rather than doing heavy computation.

The threading Module

Python's built-in threading module lets you create and manage threads using the Thread class.

The Global Interpreter Lock (GIL)

CPython has a Global Interpreter Lock that allows only one thread to execute Python bytecode at a time. This means threading does NOT speed up CPU-bound tasks (pure computation), but it DOES help with I/O-bound tasks because threads can wait on I/O while others run.

Creating and Starting Threads

Create a Thread object with a target function, call .start() to begin execution, and .join() to wait for it to finish.

Thread Safety

When multiple threads access shared data, race conditions can occur. Use a Lock to ensure only one thread modifies shared data at a time.

When to Use Threading vs Multiprocessing

Use threading for I/O-bound tasks (network requests, file I/O). Use the multiprocessing module for CPU-bound tasks, since each process gets its own Python interpreter and GIL, enabling true parallelism.

Syntax

<pre><code>import threading
import time

def download_file(name, delay):
    print(f"Starting download: {name}")
    time.sleep(delay)  # simulates I/O wait
    print(f"Finished download: {name}")

# Creating and starting threads
thread1 = threading.Thread(target=download_file, args=("file1.zip", 2))
thread2 = threading.Thread(target=download_file, args=("file2.zip", 3))

thread1.start()
thread2.start()

# Wait for both threads to finish
thread1.join()
thread2.join()
print("All downloads complete!")

# Using a Lock to protect shared data
counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100000):
        with lock:   # only one thread can hold the lock at a time
            counter += 1

threads = [threading.Thread(target=increment) for _ in range(2)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print(f"Final counter: {counter}")  # 200000, safe thanks to the lock
</code></pre>

Revision Notes

• Threading is best for I/O-bound tasks (network, file, disk)
• The GIL means only one thread executes Python bytecode at a time
• Thread(target=func, args=(...)) creates a thread; .start() runs it
• .join() blocks until the thread finishes
• Use threading.Lock() to prevent race conditions on shared data
• Use multiprocessing instead for CPU-bound parallelism

Simulate Concurrent Downloads

Medium

Write a function run_downloads(tasks) where tasks is a list of (name, delay) tuples. Using the threading module, start a thread for each task that sleeps for `delay` seconds then appends `name` to a shared results list. Wait for all threads to finish and return the results list (order may vary).

Input:

[("A", 0.05), ("B", 0.02)]

Output:

['B', 'A'] (order depends on delay)

Show Hint

Create a Thread for each task with a target function that sleeps then appends to a shared list. Start all threads, then join() each one before returning.

Solve this Challenge

Show Solution

import threading
import time

def run_downloads(tasks):
    results = []

    def worker(name, delay):
        time.sleep(delay)
        results.append(name)

    threads = [threading.Thread(target=worker, args=(name, delay)) for name, delay in tasks]
    for t in threads:
        t.start()
    for t in threads:
        t.join()

    return results

print(run_downloads([("A", 0.05), ("B", 0.02)]))

Asynchronous Programming with asyncio