Multithreading in Python

import threading
import time

def download(url, duration):
    print(f"[{threading.current_thread().name}] Starting: {url}")
    time.sleep(duration)   # simulate network wait
    print(f"[{threading.current_thread().name}] Done: {url}")

# Sequential — total time = sum of all durations
start = time.perf_counter()
download("page_a.html", 2)
download("page_b.html", 1)
download("page_c.html", 3)
print(f"Sequential: {time.perf_counter() - start:.2f}s
")

# Concurrent — total time ≈ longest single duration
start = time.perf_counter()
threads = [
    threading.Thread(target=download, args=("page_a.html", 2), name="T1"),
    threading.Thread(target=download, args=("page_b.html", 1), name="T2"),
    threading.Thread(target=download, args=("page_c.html", 3), name="T3"),
]
for t in threads: t.start()
for t in threads: t.join()    # wait for all to finish
print(f"Concurrent: {time.perf_counter() - start:.2f}s")

import threading, time

def cpu_task(n):
    """CPU-bound — holds the GIL while computing."""
    return sum(i * i for i in range(n))

def io_task(seconds):
    """I/O-bound — releases the GIL while sleeping."""
    time.sleep(seconds)

# I/O-bound: real speedup from threading
start = time.perf_counter()
threads = [threading.Thread(target=io_task, args=(1,)) for _ in range(5)]
for t in threads: t.start()
for t in threads: t.join()
print(f"5 I/O tasks with threads: {time.perf_counter() - start:.2f}s")   # ~1.0s

# CPU-bound: no speedup — GIL prevents true parallelism
start = time.perf_counter()
threads = [threading.Thread(target=cpu_task, args=(2_000_000,)) for _ in range(4)]
for t in threads: t.start()
for t in threads: t.join()
print(f"4 CPU tasks with threads: {time.perf_counter() - start:.2f}s")   # no improvement

import threading

counter = 0

def increment_unsafe():
    global counter
    for _ in range(100_000):
        counter += 1   # read-modify-write — NOT atomic, unsafe under threads

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

# Unsafe — race condition → wrong result
counter = 0
threads = [threading.Thread(target=increment_unsafe) for _ in range(5)]
for t in threads: t.start()
for t in threads: t.join()
print("Unsafe:", counter)    # typically much less than 500,000

# Safe — Lock prevents race condition
counter = 0
lock = threading.Lock()
threads = [threading.Thread(target=increment_safe, args=(lock,)) for _ in range(5)]
for t in threads: t.start()
for t in threads: t.join()
print("Safe:  ", counter)    # always exactly 500,000

from concurrent.futures import ThreadPoolExecutor, as_completed
import time

def fetch(url):
    time.sleep(1)   # simulate a 1-second API call
    return f"Response from {url}"

urls = [
    "https://api.example.com/users",
    "https://api.example.com/orders",
    "https://api.example.com/products",
    "https://api.example.com/reports",
]

start = time.perf_counter()

with ThreadPoolExecutor(max_workers=4) as executor:
    # submit() returns Future objects immediately
    futures = {executor.submit(fetch, url): url for url in urls}

    # as_completed yields futures as they finish (not submission order)
    for future in as_completed(futures):
        url  = futures[future]
        result = future.result()
        print(f"{url.split('/')[-1]}: {result[:30]}")

print(f"All done in {time.perf_counter() - start:.2f}s")

# executor.map() alternative — simpler, results in submission order
print("
Using map:")
with ThreadPoolExecutor(max_workers=4) as executor:
    for result in executor.map(fetch, urls):
        print(result[:40])

import threading, time

def background_monitor():
    while True:
        print("[Monitor] Checking system health...")
        time.sleep(2)

# daemon=True — thread dies automatically when main thread exits
monitor = threading.Thread(target=background_monitor, daemon=True, name="HealthMonitor")
monitor.start()

print(f"Main thread working... (monitor: {monitor.name}, daemon={monitor.daemon})")
time.sleep(3)
print("Main thread done — daemon thread is killed automatically")