Python Multithreading – Concurrent Execution with Threads

Creating Threads

Use threading.Thread to create and start threads.

import threading
import time

def download(site):
    print(f"Downloading {site}...")
    time.sleep(2)   # Simulate network I/O
    print(f"Done: {site}")

# Without threads: takes 6 seconds
# With threads: takes ~2 seconds
threads = []
for site in ["google.com", "github.com", "python.org"]:
    t = threading.Thread(target=download, args=(site,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()   # Wait for all to complete
print("All downloads done")

The GIL – Global Interpreter Lock

The GIL prevents multiple threads from executing Python bytecode simultaneously. This means threads DO NOT speed up CPU-bound tasks (computation). They DO help I/O-bound tasks because threads release the GIL while waiting for I/O.

Thread Safety – Using Locks

When threads share data, use a Lock to prevent race conditions.

import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100_000):
        with lock:      # Only one thread at a time
            counter += 1

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

print(f"Counter: {counter}")  # Always 500000 with lock

ThreadPoolExecutor – High-Level API

concurrent.futures.ThreadPoolExecutor is the modern, higher-level threading API.

from concurrent.futures import ThreadPoolExecutor
import time

def fetch(url):
    time.sleep(1)   # Simulate I/O
    return f"Data from {url}"

urls = ["api.com/1", "api.com/2", "api.com/3"]

with ThreadPoolExecutor(max_workers=3) as executor:
    results = list(executor.map(fetch, urls))

for r in results:
    print(r)

The GIL: Why Python Threads Don't Speed Up Math

CPython has a Global Interpreter Lock — only one thread executes Python bytecode at a time. So threads give you concurrency (overlapping waits) but not parallelism (using multiple cores) for pure-Python computation.

from concurrent.futures import ThreadPoolExecutor
# I/O-bound → threads shine
with ThreadPoolExecutor() as pool:
    pages = list(pool.map(download, urls))

from concurrent.futures import ProcessPoolExecutor
# CPU-bound → separate processes, each its OWN GIL/core
with ProcessPoolExecutor() as pool:
    results = list(pool.map(heavy_math, chunks))

The rule of thumb: I/O-bound → threading or asyncio; CPU-bound → multiprocessing (dodges the GIL by running real separate processes). Also watch shared state: because threads interleave, unguarded shared variables cause race conditions — protect them with a threading.Lock.

Interview Questions on Multithreading

• What is a thread and what is multithreading?
• What is the GIL and how does it affect Python threads?
• When is threading beneficial in Python despite the GIL?
• What is a race condition and how do locks prevent it?
• What is the difference between Lock and RLock?
• What does ThreadPoolExecutor provide?
• What is the difference between threading and multiprocessing?

Related Topics