Python Threading

Learning Objectives

Threading is another important concurrency technique in Python. It is especially useful when a program needs to manage multiple I/O-bound operations.

What Is Threading?

A thread is a unit of execution within a process.

A Python program normally starts with at least one thread, commonly called the main thread.

Threading allows an application to create additional threads that can perform work concurrently.

Threads are particularly useful when tasks spend significant time waiting for external resources.

Concurrency & Parallelism

These two terms are related but they are not identical.

Python threading can be very useful for concurrency, especially for I/O-bound work.

For CPU-heavy workloads, multiprocessing or other approaches may be more appropriate.

The threading Module

Python provides the threading module in its standard library.

import threading

It provides classes and functions for creating and coordinating threads.

Your First Thread

The simplest way to create a thread is to pass a function to threading.Thread.

import threading


def worker():

    print("Worker thread is running")


thread = threading.Thread(
    target=worker
)

thread.start()

The target specifies the function that the thread should execute.

The thread does not begin execution until start() is called.

start() & join()

Two important thread methods are start() and join().

start()

Starts the thread's execution.

join()

Waits for the thread to finish.

import threading


def worker():

    print("Worker started")

    for number in range(3):

        print(number)


thread = threading.Thread(
    target=worker
)

thread.start()

thread.join()

print("Main thread finished")

Creating Multiple Threads

You can create several threads and start them before waiting for them to finish.

import threading
import time


def worker(name):

    print(name, "started")

    time.sleep(2)

    print(name, "finished")


threads = []


for name in ["Thread A", "Thread B", "Thread C"]:

    thread = threading.Thread(
        target=worker,
        args=(name,)
    )

    threads.append(thread)

    thread.start()


for thread in threads:

    thread.join()


print("All threads finished")

The three threads can overlap their waiting periods.

Passing Arguments to Threads

Use args to pass positional arguments to the target function.

import threading


def greet(name):

    print("Hello,", name)


thread = threading.Thread(
    target=greet,
    args=("Ali",)
)

thread.start()

thread.join()

Notice the comma in ("Ali",). This creates a one-element tuple.

Keyword Arguments

thread = threading.Thread(
    target=greet,
    kwargs={"name": "Sara"}
)

Threading with a Class

For more complex behavior, you can create a class that inherits from threading.Thread.

import threading


class Worker(threading.Thread):

    def run(self):

        print("Worker is running")


thread = Worker()

thread.start()

thread.join()

The run() method contains the work performed by the thread.

Daemon Threads

A daemon thread is intended to run in the background and does not normally keep the Python process alive after all non-daemon threads have finished.

import threading
import time


def background_task():

    while True:

        print("Background task running")

        time.sleep(1)


thread = threading.Thread(
    target=background_task,
    daemon=True
)

thread.start()

print("Main program continues")

Race Conditions

A race condition can occur when multiple threads access shared mutable data and the final result depends on the timing of their operations.

Consider a shared counter:

counter = 0


def increment():

    global counter

    for _ in range(100000):

        counter += 1

If several threads modify shared state, you should not assume that the operations are automatically safe.

Thread Locks

A Lock can protect a critical section so that only one thread at a time enters it.

import threading


counter = 0

lock = threading.Lock()


def increment():

    global counter

    for _ in range(100000):

        with lock:

            counter += 1

The with lock: block acquires the lock before entering the critical section and releases it afterward.

RLock

threading.RLock is a reentrant lock.

It allows the same thread to acquire the lock multiple times without deadlocking itself, provided it releases the lock the corresponding number of times.

import threading


lock = threading.RLock()


def outer():

    with lock:

        inner()


def inner():

    with lock:

        print("Nested lock acquisition")


outer()

Semaphores

A semaphore limits how many threads can access a resource at the same time.

import threading
import time


semaphore = threading.Semaphore(2)


def worker(name):

    with semaphore:

        print(name, "entered")

        time.sleep(2)

        print(name, "left")

A semaphore initialized with 2 allows up to two threads to hold the semaphore simultaneously.

Events

A threading.Event provides a simple way for threads to communicate that something has happened.

import threading
import time


ready = threading.Event()


def worker():

    print("Worker waiting...")

    ready.wait()

    print("Worker received signal")


thread = threading.Thread(
    target=worker
)

thread.start()

time.sleep(2)

print("Main thread signals worker")

ready.set()

thread.join()

The worker waits until another thread calls set().

Thread-Safe Queues

The queue module provides thread-safe structures that are particularly useful for producer and consumer patterns.

import queue


tasks = queue.Queue()

tasks.put("Download file")
tasks.put("Process order")
tasks.put("Send email")

print(tasks.get())
print(tasks.get())

A producer can add work to a queue while one or more consumers retrieve and process that work.

ThreadPoolExecutor

For many applications, manually creating and managing individual threads is unnecessary.

The concurrent.futures module provides ThreadPoolExecutor for managing a pool of worker threads.

from concurrent.futures import ThreadPoolExecutor


def process_order(order):

    return f"Processed {order}"


orders = [
    "Order 101",
    "Order 102",
    "Order 103",
    "Order 104"
]


with ThreadPoolExecutor(
    max_workers=4
) as executor:

    results = executor.map(
        process_order,
        orders
    )


for result in results:

    print(result)

The executor manages the worker threads for you.

Exceptions in Threads

Exceptions raised inside a worker thread require careful handling. With ThreadPoolExecutor, exceptions can be retrieved from Future objects.

from concurrent.futures import ThreadPoolExecutor


def divide(number):

    return 100 / number


numbers = [10, 5, 0, 20]


with ThreadPoolExecutor(
    max_workers=4
) as executor:

    futures = [
        executor.submit(divide, number)
        for number in numbers
    ]

    for future in futures:

        try:

            print(future.result())

        except ZeroDivisionError:

            print("Cannot divide by zero")

Calling future.result() retrieves the result or re-raises an exception that occurred in the worker.

Threading vs Async Python

You have just learned threading after studying asynchronous programming. It is important to understand when the two approaches differ.

Threading for I/O-Bound Work

Threads can be particularly useful when tasks spend a lot of time waiting for external operations.

Example

from concurrent.futures import ThreadPoolExecutor
import time


def download_file(filename):

    print("Downloading", filename)

    time.sleep(2)

    return filename + " downloaded"


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


with ThreadPoolExecutor(
    max_workers=3
) as executor:

    results = executor.map(
        download_file,
        files
    )


for result in results:

    print(result)

This example simulates three independent downloads.

Real-World Applications

Threading can be useful in many practical applications.

Common Threading Mistakes

threading.Thread(
    target=worker()
)

threading.Thread(
    target=worker
)

Practice Exercises

Mini Challenge — Ecommerce Order Processor

Build a threaded ecommerce order-processing simulation.

Starter Code

from concurrent.futures import ThreadPoolExecutor
import time


orders = [
    {"id": 101, "customer": "Ali"},
    {"id": 102, "customer": "Sara"},
    {"id": 103, "customer": "Ahmed"},
    {"id": 104, "customer": "Hina"},
    {"id": 105, "customer": "Usman"}
]


def process_order(order):

    print(
        "Processing order",
        order["id"]
    )

    time.sleep(2)

    return {
        "id": order["id"],
        "status": "Completed"
    }


with ThreadPoolExecutor(
    max_workers=3
) as executor:

    results = executor.map(
        process_order,
        orders
    )


for result in results:

    print(result)

Knowledge Check

Test your understanding of Python threading.

Lesson Summary

Python threading provides a way to perform multiple operations concurrently using threads. It is especially useful for applications that spend significant time waiting for I/O operations.