Thread — Explained with Examples

A thread is the smallest unit of execution within a process, sharing memory space with other threads for efficient concurrent work.

Threads are lightweight execution units that run within a process. Multiple threads in the same process share memory (heap, global variables) but each has its own stack and program counter. User-level threads are managed by a runtime library without kernel involvement. Kernel-level threads are managed by the operating system. Most modern systems use a hybrid where user threads are multiplexed onto kernel threads.

Think of a thread like a worker on an assembly line. Each worker has their own tools (stack) but shares the factory floor (heap memory) with other workers. They can pass parts directly to each other without going through management (inter-thread communication via shared memory).

Threads enable concurrency within a single process: a web server can handle multiple requests simultaneously, a UI can stay responsive during background computation, and parallel computations can divide work across CPU cores.

import threading
import time

def worker(name, delay):
    for i in range(3):
        print(f"Thread {name}: iteration {i}")
        time.sleep(delay)

# Create threads
threads = []
for name, delay in [("A", 0.5), ("B", 1.0), ("C", 0.3)]:
    t = threading.Thread(target=worker, args=(name, delay))
    threads.append(t)
    t.start()

# Wait for all threads to complete
for t in threads:
    t.join()

print("All threads completed")

Threading introduces challenges: race conditions, deadlocks, and complexity in debugging. Alternatives like async/await and actor models address some of these issues.

Process, Concurrency, Mutex, Goroutine, Coroutine

Concurrency vs Parallelism