Python

What You'll Learn Here

What is a thread — understanding the concept
Why use threads — benefits and use cases
Creating threads — using the threading module
Joining threads — waiting for threads to finish
Daemon threads — background tasks
Real-world examples — practical applications

What is a Thread?

A thread is a separate flow of execution within a program. Think of it like a worker who can do one task at a time. When you have multiple threads, it's like having multiple workers who can work on different tasks simultaneously.

🍳 Think of it like cooking in a kitchen.

Imagine you're cooking a meal. You could chop vegetables, then boil pasta, then prepare the sauce one after another. That's like a single-threaded program.

But if you have a helper, one person can chop vegetables while the other boils pasta. Both tasks happen at the same time. That's like multi-threading!

Single Thread

One task at a time, sequential execution

Multiple Threads

Multiple tasks running simultaneously

Thread Safety

Managing shared data between threads

💡 Key concept: A program is like a process. A thread is a lightweight unit of execution within that process. Multiple threads share the same memory space.

Thread vs Process

# ============================================================
# THREAD VS PROCESS
# ============================================================

print("""
┌─────────────────────────────────────────────────────────────────┐
│                         PROCESS                                │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │                     MEMORY SPACE                        │  │
│  │  ┌─────┐  ┌─────┐  ┌─────┐                            │  │
│  │  │Thread│  │Thread│  │Thread│   <-- Multiple threads   │  │
│  │  │  1   │  │  2   │  │  3   │    share memory          │  │
│  │  └─────┘  └─────┘  └─────┘                            │  │
│  └──────────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘

Key Differences:
- Processes have separate memory space
- Threads share memory space (more efficient)
- Processes are heavier (more resources)
- Threads are lightweight
- Processes are isolated; threads communicate easily
""")

Key point: Threads are lightweight and share memory, making them efficient for tasks that need to communicate.

Quick Check: What is a thread? (Answer: A separate flow of execution within a program)

Why Use Threads?

Benefits of Using Threads

# ============================================================
# WHY USE THREADS?
# ============================================================

print("""
1. IMPROVED PERFORMANCE
   - Multiple tasks run simultaneously
   - Better CPU utilization
   - Faster execution for I/O-bound tasks

2. BETTER RESPONSIVENESS
   - UI remains responsive while processing
   - No "freezing" in applications

3. RESOURCE EFFICIENCY
   - Threads share memory
   - Less overhead than processes

4. SIMPLER PROGRAMMING
   - Natural way to handle concurrent tasks
   - Cleaner code structure

5. REAL-WORLD APPLICATIONS
   - Web servers handling multiple requests
   - Download managers downloading multiple files
   - GUI applications processing background tasks
""")

# ============================================================
# COMMON USE CASES
# ============================================================

print("""
┌─────────────────────────────┬─────────────────────────────────────┐
│ Use Case                    │ Why Threads Help                   │
├─────────────────────────────┼─────────────────────────────────────┤
│ Web Scraping                │ Fetch multiple pages at once       │
│ File Processing             │ Process multiple files in parallel │
│ Database Operations         │ Run multiple queries concurrently  │
│ GUI Applications            │ Keep UI responsive                 │
│ API Calls                   │ Make multiple API calls at once    │
│ Download Managers           │ Download multiple files at once    │
└─────────────────────────────┴─────────────────────────────────────┘
""")

Key point: Threads help you do multiple things at once, making your program faster and more responsive.

Quick Check: Why would you use threads in a GUI application? (Answer: To keep the UI responsive while performing background tasks)

The threading Module

Introduction to Python's threading Module

Python's threading module provides a way to create and manage threads. It's built into Python, so you don't need to install anything.

# ============================================================
# BASIC THREADING
# ============================================================

import threading
import time

# ============================================================
# 1. SIMPLE THREAD EXAMPLE
# ============================================================

def print_numbers():
    """Print numbers from 1 to 5"""
    for i in range(1, 6):
        print(f"Number: {i}")
        time.sleep(0.5)

def print_letters():
    """Print letters from A to E"""
    for letter in ['A', 'B', 'C', 'D', 'E']:
        print(f"Letter: {letter}")
        time.sleep(0.5)

# Create threads
thread1 = threading.Thread(target=print_numbers)
thread2 = threading.Thread(target=print_letters)

# Start threads
thread1.start()
thread2.start()

# Wait for threads to finish
thread1.join()
thread2.join()

print("Both threads finished!")

# ============================================================
# 2. THREAD WITH ARGUMENTS
# ============================================================

def greet(name, times):
    """Greet a person multiple times"""
    for i in range(times):
        print(f"Hello, {name}! (Greeting {i+1})")
        time.sleep(0.3)

thread = threading.Thread(target=greet, args=("Alice", 3))
thread.start()
thread.join()

# ============================================================
# 3. THREAD COUNT
# ============================================================

print(f"Active threads: {threading.active_count()}")
print(f"Current thread: {threading.current_thread().name}")

threading module key points:

Thread(target=function) — creates a thread
start() — starts the thread
join() — waits for the thread to finish
active_count() — number of active threads
current_thread() — information about current thread

Quick Check: What method starts a thread? (Answer: start())

Creating Threads

Two Ways to Create Threads

# ============================================================
# TWO WAYS TO CREATE THREADS
# ============================================================

import threading
import time

# ============================================================
# METHOD 1: FUNCTION TARGET
# ============================================================

def worker(name, delay):
    """Simulate work"""
    print(f"Worker {name} starting...")
    time.sleep(delay)
    print(f"Worker {name} finished!")

# Create threads using function target
thread1 = threading.Thread(target=worker, args=("Thread-1", 2))
thread2 = threading.Thread(target=worker, args=("Thread-2", 3))

thread1.start()
thread2.start()
thread1.join()
thread2.join()

# ============================================================
# METHOD 2: SUBCLASSING THREAD
# ============================================================

class WorkerThread(threading.Thread):
    """Custom thread class"""
    
    def __init__(self, name, delay):
        threading.Thread.__init__(self)
        self.name = name
        self.delay = delay
    
    def run(self):
        """Code to run in the thread"""
        print(f"Thread {self.name} starting...")
        time.sleep(self.delay)
        print(f"Thread {self.name} finished!")

# Create thread objects
thread3 = WorkerThread("Thread-3", 2)
thread4 = WorkerThread("Thread-4", 3)

thread3.start()
thread4.start()
thread3.join()
thread4.join()

print("All threads finished!")

# ============================================================
# WHICH METHOD TO USE?
# ============================================================

print("""
┌─────────────────────────────────────────────────────────────────┐
│ Method 1: Function Target                                     │
│ ✅ Simpler and more Pythonic                                   │
│ ✅ Good for simple tasks                                      │
│ ✅ Less boilerplate code                                      │
├─────────────────────────────────────────────────────────────────┤
│ Method 2: Subclassing Thread                                  │
│ ✅ More object-oriented                                       │
│ ✅ Better for complex threads                                 │
│ ✅ Can have custom attributes and methods                     │
└─────────────────────────────────────────────────────────────────┘
""")

Creating threads key points:

Function target — simpler, recommended for most cases
Subclassing Thread — for complex thread behavior
run() method — define thread behavior in subclass
__init__ — pass custom arguments to thread

Quick Check: What method do you override when subclassing Thread? (Answer: run())

Joining Threads

Waiting for Threads to Finish

The join() method makes the main program wait for a thread to finish before continuing.

# ============================================================
# JOINING THREADS
# ============================================================

import threading
import time

# ============================================================
# WITHOUT JOIN - Threads run and program may finish early
# ============================================================

def slow_task(name, seconds):
    print(f"Task {name} started")
    time.sleep(seconds)
    print(f"Task {name} finished")

print("1. WITHOUT JOIN:")
t1 = threading.Thread(target=slow_task, args=("A", 2))
t1.start()
# No join - program may finish before thread completes
print("Main program continuing...")
time.sleep(1)
print("Main program finished (maybe before thread)")

print("\n" + "=" * 40)

# ============================================================
# WITH JOIN - Program waits for thread
# ============================================================

print("\n2. WITH JOIN:")
t2 = threading.Thread(target=slow_task, args=("B", 2))
t2.start()
t2.join()  # Wait for thread to finish
print("Main program finished (after thread)")

print("\n" + "=" * 40)

# ============================================================
# JOIN WITH TIMEOUT
# ============================================================

print("\n3. JOIN WITH TIMEOUT:")

def long_task():
    print("Long task started")
    time.sleep(5)
    print("Long task finished")

t3 = threading.Thread(target=long_task)
t3.start()
t3.join(timeout=2)  # Wait at most 2 seconds

if t3.is_alive():
    print("Thread is still running (timeout reached)")
else:
    print("Thread finished within timeout")

# ============================================================
# JOINING MULTIPLE THREADS
# ============================================================

print("\n4. JOINING MULTIPLE THREADS:")

def work(name):
    print(f"{name} working...")
    time.sleep(1)
    print(f"{name} done!")

threads = []
for i in range(3):
    t = threading.Thread(target=work, args=(f"Thread-{i+1}",))
    threads.append(t)
    t.start()

# Join all threads
for t in threads:
    t.join()

print("All threads finished!")

join() key points:

join() — waits for thread to finish
join(timeout) — waits for specified seconds
is_alive() — checks if thread is still running
Important — always join threads to avoid race conditions

Quick Check: What does join() do? (Answer: It makes the program wait for the thread to finish)

Daemon Threads

Background Threads That Don't Block Program Exit

A daemon thread runs in the background and does not prevent the program from exiting. When all non-daemon threads finish, the program exits, and daemon threads are abruptly stopped.

# ============================================================
# DAEMON THREADS
# ============================================================

import threading
import time

# ============================================================
# 1. NON-DAEMON THREAD (Default)
# ============================================================

print("1. NON-DAEMON THREAD:")

def non_daemon_task():
    for i in range(5):
        print(f"Non-daemon: {i}")
        time.sleep(1)

t1 = threading.Thread(target=non_daemon_task)
t1.start()
# Program waits for this thread to finish
print("Main program - waiting for non-daemon thread...")

# ============================================================
# 2. DAEMON THREAD
# ============================================================

print("\n2. DAEMON THREAD:")

def daemon_task():
    for i in range(10):
        print(f"Daemon: {i}")
        time.sleep(0.5)

t2 = threading.Thread(target=daemon_task)
t2.daemon = True  # Set as daemon
t2.start()

# Program will exit immediately without waiting for daemon
print("Main program - not waiting for daemon thread...")
time.sleep(2)
print("Main program exiting (daemon will be terminated)")

# ============================================================
# 3. DAEMON WITH JOIN
# ============================================================

print("\n3. DAEMON WITH JOIN:")

def background_task():
    for i in range(5):
        print(f"Background: {i}")
        time.sleep(1)

t3 = threading.Thread(target=background_task)
t3.daemon = True
t3.start()
# t3.join()  # Uncomment to wait for daemon
print("Main program - with or without join?")

# ============================================================
# WHEN TO USE DAEMON THREADS
# ============================================================

print("""
┌─────────────────────────────────────────────────────────────────┐
│ WHEN TO USE DAEMON THREADS                                    │
├─────────────────────────────────────────────────────────────────┤
│ ✅ Background monitoring                                      │
│ ✅ Logging threads                                            │
│ ✅ Health checks                                              │
│ ✅ Periodic cleanup tasks                                     │
│ ✅ Cache refreshing                                           │
│                                                                 │
│ ❌ Critical tasks that must complete                           │
│ ❌ Data processing that must finish                           │
│ ❌ Tasks that need to be reliable                              │
└─────────────────────────────────────────────────────────────────┘
""")

Daemon threads key points:

daemon = True — makes thread a daemon
Exits with program — doesn't block program exit
Abrupt termination — may not complete its work
Best for background tasks — not critical operations

Quick Check: What is a daemon thread? (Answer: A background thread that doesn't prevent the program from exiting)

Real-World Example: Download Manager

Building a Download Manager with Threads

# ============================================================
# DOWNLOAD MANAGER WITH THREADS
# ============================================================

import threading
import time
import random

class DownloadManager:
    """Simulate a download manager using threads"""
    
    def __init__(self):
        self.downloads = []
        self.completed = 0
        self.lock = threading.Lock()  # For thread safety
    
    def download_file(self, file_name, size_mb):
        """Simulate downloading a file"""
        thread_id = threading.current_thread().name
        
        print(f"[{thread_id}] Starting download: {file_name} ({size_mb}MB)")
        self.downloads.append(file_name)
        
        # Simulate download progress
        for progress in range(0, 101, 10):
            time.sleep(random.uniform(0.2, 0.5))
            print(f"[{thread_id}] {file_name}: {progress}% complete")
        
        # Thread-safe counter update
        with self.lock:
            self.completed += 1
        
        print(f"[{thread_id}] Completed: {file_name}")
        return file_name
    
    def start_downloads(self, files):
        """Start multiple downloads in parallel"""
        threads = []
        
        for file_name, size in files:
            thread = threading.Thread(
                target=self.download_file,
                args=(file_name, size),
                name=f"Download-{file_name[:5]}"
            )
            threads.append(thread)
            thread.start()
        
        # Wait for all downloads to complete
        for thread in threads:
            thread.join()
        
        print(f"\nAll downloads completed! Total: {self.completed} files")
        print(f"Files downloaded: {', '.join(self.downloads)}")

# ============================================================
# RUN THE DOWNLOAD MANAGER
# ============================================================

if __name__ == "__main__":
    manager = DownloadManager()
    
    # List of files to download (name, size in MB)
    files_to_download = [
        ("movie.mp4", 150),
        ("document.pdf", 5),
        ("music.mp3", 10),
        ("image.jpg", 3),
        ("game.exe", 500)
    ]
    
    print("=" * 60)
    print("DOWNLOAD MANAGER")
    print("=" * 60)
    print("Starting downloads in parallel...\n")
    
    start_time = time.time()
    manager.start_downloads(files_to_download)
    end_time = time.time()
    
    print(f"\nTotal time: {end_time - start_time:.2f} seconds")
    print("Downloads completed successfully!")

# ============================================================
# WHY THREADS ARE USEFUL HERE
# ============================================================

print("""
Why threads make this better:
1. Each download runs in its own thread
2. Downloads happen simultaneously
3. Total time = time of slowest download (not sum of all)
4. User interface remains responsive
5. Can add progress tracking and cancellation

Without threads: 5 downloads would take 5x longer!
""")

Real-world example key points:

Parallel downloads — each file downloads in its own thread
Thread safety — using locks for shared data
Progress tracking — each thread reports progress
Performance — total time is reduced significantly

Quick Check: Why are threads useful for a download manager? (Answer: They allow multiple downloads to happen simultaneously)

Best Practices

Threading Best Practices

# ============================================================
# THREADING BEST PRACTICES
# ============================================================

print("1. USE THREAD SAFE DATA STRUCTURES")
print("   - Use Queue for thread-safe communication")
print("   - Use Lock for shared data access")
print("   - Example: from queue import Queue")

print("\n2. ALWAYS JOIN THREADS")
print("   - Ensure threads complete before program exits")
print("   - Prevents resource leaks")

print("\n3. AVOID SHARING MODIFIABLE DATA")
print("   - Pass data through queues")
print("   - Use immutability when possible")

print("\n4. USE DAEMON THREADS FOR BACKGROUND TASKS")
print("   - Don't use for critical operations")
print("   - They may not complete")

print("\n5. HANDLE EXCEPTIONS IN THREADS")
print("   - Exceptions in threads don't propagate to main")
print("   - Use try/except inside thread functions")

print("\n6. LIMIT THE NUMBER OF THREADS")
print("   - Too many threads = performance degradation")
print("   - Use thread pools for many tasks")

print("\n7. USE THREAD POOLS FOR MANY TASKS")
print("   - from concurrent.futures import ThreadPoolExecutor")
print("   - Reuses threads for efficiency")

print("\n8. DON'T USE THREADS FOR CPU-BOUND TASKS")
print("   - Use multiprocessing instead")
print("   - Python's GIL limits CPU-bound threading")

Best practices summary:

Use thread-safe structures — Queue, Lock
Always join threads — prevent resource leaks
Minimize shared data — avoid race conditions
Handle exceptions — inside thread functions
Don't over-thread — use thread pools

Quick Check: What should you use for thread-safe communication? (Answer: Queue)

Try It Yourself

Experiment with threads in the editor below.

Loading Pyodide... 0%

Python Code Editor

# Python Threads - Practice

print("=" * 40)
print("THREADS - PRACTICE")
print("=" * 40)

# Simulated Threading Environment
class SimulatedThread:
    def __init__(self, name, target, args=()):
        self.name = name
        self.target = target
        self.args = args
        self.is_alive = False
    
    def start(self):
        self.is_alive = True
        print(f"Thread '{self.name}' started")
        # Simulate running the target
        if self.target:
            self.target(*self.args)
        self.is_alive = False
    
    def join(self):
        print(f"Waiting for thread '{self.name}' to finish...")
        # Simulate waiting
        self.is_alive = False
        print(f"Thread '{self.name}' joined")

def task(name, delay):
    print(f"Task {name}: Working...")
    # Simulate work
    print(f"Task {name}: Done!")

print("\n1. CREATING AND STARTING THREADS")
print("-" * 40)

t1 = SimulatedThread("Thread-1", task, ("A", 1))
t2 = SimulatedThread("Thread-2", task, ("B", 1))

t1.start()
t2.start()

print("\n2. JOINING THREADS")
print("-" * 40)

t1.join()
t2.join()

print("\n3. MULTIPLE THREADS EXAMPLE")
print("-" * 40)

def worker(worker_id):
    print(f"Worker {worker_id}: Starting")
    # Simulate work
    print(f"Worker {worker_id}: Finished")

threads = []
for i in range(3):
    t = SimulatedThread(f"Worker-{i+1}", worker, (i+1,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print("\n4. THREADING CONCEPTS SUMMARY")
print("-" * 40)
print("""
┌─────────────────────────────────────────────────────────────────┐
│ Concept        │ Description                                  │
├─────────────────────────────────────────────────────────────────┤
│ Thread         │ Separate flow of execution                   │
│ start()        │ Begins thread execution                      │
│ join()         │ Waits for thread to finish                   │
│ Daemon Thread  │ Background thread, exits with program        │
│ Thread Safety  │ Managing shared data between threads         │
└─────────────────────────────────────────────────────────────────┘
""")

print("Threads allow multiple tasks to run concurrently!")

========================================
THREADS - PRACTICE
========================================

1. CREATING AND STARTING THREADS
----------------------------------------
Thread 'Thread-1' started
Task A: Working...
Task A: Done!
Thread 'Thread-2' started
Task B: Working...
Task B: Done!

2. JOINING THREADS
----------------------------------------
Waiting for thread 'Thread-1' to finish...
Thread 'Thread-1' joined
Waiting for thread 'Thread-2' to finish...
Thread 'Thread-2' joined

3. MULTIPLE THREADS EXAMPLE
----------------------------------------
Thread 'Worker-1' started
Worker 1: Starting
Worker 1: Finished
Thread 'Worker-2' started
Worker 2: Starting
Worker 2: Finished
Thread 'Worker-3' started
Worker 3: Starting
Worker 3: Finished
Waiting for thread 'Worker-1' to finish...
Thread 'Worker-1' joined
Waiting for thread 'Worker-2' to finish...
Thread 'Worker-2' joined
Waiting for thread 'Worker-3' to finish...
Thread 'Worker-3' joined

4. THREADING CONCEPTS SUMMARY
----------------------------------------
┌─────────────────────────────────────────────────────────────────┐
│ Concept │ Description │
├─────────────────────────────────────────────────────────────────┤
│ Thread │ Separate flow of execution │
│ start() │ Begins thread execution │
│ join() │ Waits for thread to finish │
│ Daemon Thread │ Background thread, exits with program │
│ Thread Safety │ Managing shared data between threads │
└─────────────────────────────────────────────────────────────────┘

Threads allow multiple tasks to run concurrently!

🏆

You've Got It!

You now understand threads in Python. You know what threads are, why they're useful, and how to create and manage them.

Quick Quiz

Test what you've learned:

1. What is a thread?

A) A complete program B) A separate flow of execution within a program C) A type of function D) A database connection

2. What method starts a thread?

A) run() B) start() C) begin() D) execute()

3. What does join() do?

A) Starts the thread B) Waits for the thread to finish C) Stops the thread D) Creates a thread

4. What is a daemon thread?

A) A thread that runs forever B) A background thread that doesn't block program exit C) A thread that runs only once D) A thread that uses no resources

5. Why should you limit the number of threads?

A) Threads don't use resources B) Too many threads can slow down performance C) Threads are unlimited D) Threads don't affect performance

Frequently Asked Questions

What is the difference between a thread and a process?

Threads share memory space and are lightweight. Processes have separate memory and are heavier. Threads are good for I/O tasks; processes are better for CPU-bound tasks.

What is the Global Interpreter Lock (GIL) in Python?

The GIL is a mutex that prevents multiple threads from executing Python bytecode at the same time. This means CPU-bound threads don't get true parallelism in CPython. However, I/O-bound threads still benefit significantly.

What is a common interview question about threads?

Common questions include: "What is the difference between threads and processes?" "What is the GIL?" "How do you create a thread in Python?" and "What is thread synchronization and why is it important?"

When should I use threading vs asyncio?

Use threading for I/O-bound tasks with blocking operations. Use asyncio for high-concurrency I/O operations with async/await. Threading is simpler for most cases; asyncio is more scalable for many connections.

What is thread synchronization?

Thread synchronization is the process of controlling access to shared resources to prevent race conditions. Python provides Lock, RLock, Semaphore, and Event for synchronization.

Where to Go From Here

Now that you understand threads, check out these related topics:

Previous: Graphics in Python Next: Process vs Threads →

Python: Introduction to Threads

What is a Thread?

Single Thread

Multiple Threads

Thread Safety

Thread vs Process

Why Use Threads?

Benefits of Using Threads

The threading Module

Introduction to Python's threading Module

Creating Threads

Two Ways to Create Threads

Joining Threads

Waiting for Threads to Finish

Daemon Threads

Background Threads That Don't Block Program Exit

Real-World Example: Download Manager

Building a Download Manager with Threads

Best Practices

Threading Best Practices

Try It Yourself

You've Got It!

Quick Quiz

Frequently Asked Questions

What is the difference between a thread and a process?

What is the Global Interpreter Lock (GIL) in Python?

What is a common interview question about threads?

When should I use threading vs asyncio?

What is thread synchronization?

Where to Go From Here

Process vs Threads

Creating Threads

Thread Synchronization

Python

Python: Introduction to Threads

What is a Thread?

Single Thread

Multiple Threads

Thread Safety

Thread vs Process

Why Use Threads?

Benefits of Using Threads

The threading Module

Introduction to Python's threading Module

Creating Threads

Two Ways to Create Threads

Joining Threads

Waiting for Threads to Finish

Daemon Threads

Background Threads That Don't Block Program Exit

Real-World Example: Download Manager

Building a Download Manager with Threads

Best Practices

Threading Best Practices

Try It Yourself

You've Got It!

Quick Quiz

Frequently Asked Questions

What is the difference between a thread and a process? ▼

What is the Global Interpreter Lock (GIL) in Python? ▼

What is a common interview question about threads? ▼

When should I use threading vs asyncio? ▼

What is thread synchronization? ▼

Where to Go From Here

Process vs Threads

Creating Threads

Thread Synchronization

What is the difference between a thread and a process?

What is the Global Interpreter Lock (GIL) in Python?

What is a common interview question about threads?

When should I use threading vs asyncio?

What is thread synchronization?