Python Threading Tutorial: Run Code Concurrently Using the Threading Module

Threading in Python delivers real speedups when tasks spend most of their time waiting on input/output—like network requests—because threads overlap that waiting. In contrast, CPU-heavy work often gains little from threading and can even slow down due to the overhead of managing threads. The practical takeaway is to treat threading as an I/O-bound performance tool, not a general-purpose “run everything faster” switch.

The tutorial starts with a baseline: a simple function that sleeps for one second. Run once, it takes about one second; run twice synchronously, it takes about two seconds. That behavior matters because the “work” here isn’t CPU computation—it’s idle waiting. The next step introduces concurrency using the standard library’s threading module. Two Thread objects are created with a target function, started with start(), and synchronized with join() so timing is measured correctly. Without join(), the main script prints its “finished” message immediately after launching threads, even though the threads are still sleeping. With join(), the script waits until both threads complete, producing the expected ~1-second total runtime.

To scale up, the tutorial shows how to start many threads (ten) without blocking on each one. Threads are appended to a list, then joined in a second loop. This turns a task that would normally take ~10 seconds sequentially (ten sleeps) into something that completes in about one second, demonstrating how overlapping I/O waits can compress total wall-clock time.

Next comes argument passing: the sleep duration becomes a parameter, and threads are created with args so each thread can run the same function with different inputs (e.g., 1.5 seconds). The tutorial then shifts from manual thread management to a cleaner pattern: concurrent.futures.ThreadPoolExecutor. Using submit() returns Future objects, and future.result() blocks until completion. For batch work, it uses list comprehensions to submit multiple jobs and concurrent.futures.as_completed() to process results in the order tasks finish. It also demonstrates executor.map(), which runs tasks concurrently but yields results in the original input order, and notes that exceptions surface when results are retrieved from the iterator.

The real-world payoff comes with downloading 15 high-resolution images from Unsplash. A synchronous approach using requests downloads one image at a time and takes about 23 seconds. Refactoring the download loop into a single-image function and mapping it across URLs with ThreadPoolExecutor cuts the runtime to roughly five seconds—an outcome consistent with I/O-bound behavior, where threads keep the program busy while waiting on network responses.

Finally, the tutorial draws the boundary for when threading is the wrong tool: CPU-bound tasks like resizing and processing images rely on computation, where threads don’t bypass the limitations of the CPU and can add overhead. For that scenario, it points to multiprocessing as the next step, promising a follow-up focused on parallel processing for compute-heavy workloads.