Python

What You'll Learn Here

What is multi-tasking — doing multiple things at once
Threading — lightweight concurrent execution
Multiprocessing — using multiple CPU cores
Asynchronous programming — event-driven concurrency
When to use each — choosing the right approach

What is Multi Tasking?

Multi-tasking means doing multiple things at the same time. In programming, it means executing multiple tasks concurrently, making your program faster and more efficient.

🍳 Think of it like a restaurant kitchen.

Single tasking: One chef does everything — takes orders, cooks, cleans. Everything is slow.

Multi-tasking: Multiple chefs work simultaneously — one takes orders, another cooks, another cleans. Everything is fast and efficient!

Threading

Lightweight threads for I/O-bound tasks

Multiprocessing

Processes for CPU-bound tasks

Asynchronous

Event-driven for high concurrency

Combined

Mix approaches for best results

💡 Key concept: Multi-tasking makes your program faster by utilizing system resources more efficiently.

Multi-Tasking in Action

# ============================================================
# MULTI-TASKING EXAMPLE
# ============================================================

import threading
import time

def task1():
    print("Task 1: Starting...")
    time.sleep(2)
    print("Task 1: Finished!")

def task2():
    print("Task 2: Starting...")
    time.sleep(2)
    print("Task 2: Finished!")

def task3():
    print("Task 3: Starting...")
    time.sleep(2)
    print("Task 3: Finished!")

print("=" * 40)
print("MULTI-TASKING IN ACTION")
print("=" * 40)

print("\nRunning tasks in parallel...")

start = time.time()

# Create threads
t1 = threading.Thread(target=task1)
t2 = threading.Thread(target=task2)
t3 = threading.Thread(target=task3)

# Start threads
t1.start()
t2.start()
t3.start()

# Wait for threads
t1.join()
t2.join()
t3.join()

end = time.time()
print(f"\nAll tasks completed in {end - start:.2f} seconds")

print("""
┌─────────────────────────────────────────────────────────────────┐
│ OBSERVATIONS:                                                 │
├─────────────────────────────────────────────────────────────────┤
│ • Tasks run simultaneously                                   │
│ • Total time = time of slowest task (not sum of all)         │
│ • Much faster than single tasking                            │
│ • More complex than single tasking                          │
└─────────────────────────────────────────────────────────────────┘
""")

Key point: Multi-tasking runs tasks in parallel, reducing total execution time.

Quick Check: What is multi-tasking? (Answer: Doing multiple things at the same time)

Threading

Lightweight Concurrent Execution

Threading is the most common way to do multi-tasking in Python. Threads are lightweight and share memory, making them efficient for I/O-bound tasks.

# ============================================================
# THREADING EXAMPLE
# ============================================================

import threading
import time
import random

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

def download_file(file_name):
    """Simulate downloading a file"""
    thread_name = threading.current_thread().name
    size = random.randint(1, 5)
    
    print(f"[{thread_name}] Downloading {file_name} ({size}MB)")
    
    for progress in range(0, 101, 20):
        time.sleep(random.uniform(0.1, 0.3))
        print(f"[{thread_name}] {file_name}: {progress}%")
    
    print(f"[{thread_name}] {file_name}: Complete!")

# Create and start threads
files = ["file1.mp4", "file2.pdf", "file3.jpg", "file4.exe"]
threads = []

for file_name in files:
    t = threading.Thread(target=download_file, args=(file_name,))
    threads.append(t)
    t.start()

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

print("All downloads complete!")

# ============================================================
# THREADING WITH POOL
# ============================================================

from concurrent.futures import ThreadPoolExecutor

print("\n" + "=" * 40)
print("THREAD POOL EXECUTOR")
print("=" * 40)

def process_data(data_id):
    """Process data with ThreadPoolExecutor"""
    time.sleep(random.uniform(0.2, 0.5))
    return f"Data {data_id} processed"

# Use ThreadPoolExecutor
with ThreadPoolExecutor(max_workers=4) as executor:
    results = executor.map(process_data, range(10))
    
    for result in results:
        print(result)

print("""
┌─────────────────────────────────────────────────────────────────┐
│ THREADING ADVANTAGES:                                         │
├─────────────────────────────────────────────────────────────────┤
│ • Lightweight (low memory overhead)                          │
│ • Share memory (fast communication)                          │
│ • Great for I/O-bound tasks                                 │
│ • Easy to implement                                          │
├─────────────────────────────────────────────────────────────────┤
│ THREADING DISADVANTAGES:                                     │
├─────────────────────────────────────────────────────────────────┤
│ • GIL limits CPU-bound performance                          │
│ • Race conditions (need synchronization)                    │
│ • Not for CPU-intensive work                                │
└─────────────────────────────────────────────────────────────────┘
""")

Threading key points:

Lightweight — low memory overhead
Shared memory — fast communication
I/O-bound — great for waiting tasks
GIL limited — not for CPU work

Quick Check: What type of tasks are threads best for? (Answer: I/O-bound tasks)

Multiprocessing

Using Multiple CPU Cores

Multiprocessing creates separate processes, each with its own memory space. This bypasses the GIL and allows true parallelism for CPU-bound tasks.

# ============================================================
# MULTIPROCESSING EXAMPLE
# ============================================================

from multiprocessing import Pool, Process
import time
import math

# ============================================================
# CPU-BOUND TASK
# ============================================================

def cpu_intensive_task(n):
    """Calculate factorial (CPU-intensive)"""
    result = math.factorial(n)
    return f"Factorial of {n} is {result}"

def run_with_processes():
    """Run tasks with processes"""
    numbers = [100000, 120000, 140000, 160000]
    
    print("\nRunning with processes (parallel):")
    start = time.time()
    
    with Pool(processes=4) as pool:
        results = pool.map(cpu_intensive_task, numbers)
    
    end = time.time()
    print(f"Time: {end - start:.2f}s")
    
    for result in results:
        print(result)

def run_with_threads():
    """Run tasks with threads"""
    numbers = [100000, 120000, 140000, 160000]
    
    print("\nRunning with threads (GIL limited):")
    start = time.time()
    
    from concurrent.futures import ThreadPoolExecutor
    with ThreadPoolExecutor(max_workers=4) as executor:
        results = list(executor.map(cpu_intensive_task, numbers))
    
    end = time.time()
    print(f"Time: {end - start:.2f}s")
    
    for result in results:
        print(result)

# ============================================================
# COMPARE PERFORMANCE
# ============================================================

print("=" * 60)
print("PROCESSES vs THREADS - CPU-BOUND TASK")
print("=" * 60)

print("""
This task is CPU-intensive (calculating factorials).
Threads are limited by the GIL, processes are not.

Expected: Processes will be faster than threads.
""")

run_with_processes()
run_with_threads()

print("""
┌─────────────────────────────────────────────────────────────────┐
│ MULTIPROCESSING ADVANTAGES:                                    │
├─────────────────────────────────────────────────────────────────┤
│ • True parallelism on multi-core CPUs                        │
│ • Bypasses the GIL                                            │
│ • Great for CPU-bound tasks                                  │
│ • Isolated (one crash doesn't affect others)                 │
├─────────────────────────────────────────────────────────────────┤
│ MULTIPROCESSING DISADVANTAGES:                                │
├─────────────────────────────────────────────────────────────────┤
│ • Higher memory usage                                         │
│ • Slower to create processes                                 │
│ • Communication is slower (IPC)                             │
│ • More complex than threading                                │
└─────────────────────────────────────────────────────────────────┘
""")

Multiprocessing key points:

True parallelism — uses multiple cores
Bypasses GIL — no limitation
CPU-bound — great for calculations
Isolated — processes don't share memory

Quick Check: What type of tasks are processes best for? (Answer: CPU-bound tasks)

Asynchronous Programming

Event-Driven Concurrency

Asynchronous programming uses an event loop to handle many concurrent operations without threads. It's great for high-concurrency I/O applications.

# ============================================================
# ASYNCHRONOUS PROGRAMMING
# ============================================================

import asyncio
import random
import time

# ============================================================
# BASIC ASYNC EXAMPLE
# ============================================================

async def async_task(task_name, delay):
    """Asynchronous task"""
    print(f"{task_name}: Starting...")
    await asyncio.sleep(delay)  # Non-blocking wait
    print(f"{task_name}: Finished after {delay}s")
    return f"{task_name} result"

async def run_async_tasks():
    """Run multiple async tasks concurrently"""
    print("Running async tasks...")
    start = time.time()
    
    # Create tasks
    tasks = [
        async_task("Task A", 2),
        async_task("Task B", 1),
        async_task("Task C", 3)
    ]
    
    # Run concurrently
    results = await asyncio.gather(*tasks)
    
    end = time.time()
    print(f"All tasks completed in {end - start:.2f}s")
    
    for result in results:
        print(result)

# ============================================================
# WEB SCRAPING WITH ASYNC
# ============================================================

async def fetch_page(url):
    """Simulate fetching a web page"""
    print(f"Fetching: {url}")
    await asyncio.sleep(random.uniform(0.5, 1.5))
    return f"Content from {url}"

async def scrape_sites():
    """Scrape multiple sites concurrently"""
    urls = [
        "example.com/page1",
        "example.com/page2",
        "example.com/page3",
        "example.com/page4",
        "example.com/page5"
    ]
    
    print(f"Scraping {len(urls)} sites...")
    start = time.time()
    
    tasks = [fetch_page(url) for url in urls]
    results = await asyncio.gather(*tasks)
    
    end = time.time()
    print(f"All sites scraped in {end - start:.2f}s")
    
    for result in results[:3]:
        print(f"  {result}")
    if len(results) > 3:
        print(f"  ... and {len(results)-3} more")

# ============================================================
# RUN ASYNC CODE
# ============================================================

print("=" * 60)
print("ASYNCHRONOUS PROGRAMMING")
print("=" * 60)

# Run async tasks
asyncio.run(run_async_tasks())

print("\n" + "=" * 40)
asyncio.run(scrape_sites())

print("""
┌─────────────────────────────────────────────────────────────────┐
│ ASYNCHRONOUS ADVANTAGES:                                      │
├─────────────────────────────────────────────────────────────────┤
│ • High concurrency (thousands of connections)                 │
│ • Low overhead (no threads)                                   │
│ • Great for I/O-bound, high-volume tasks                    │
│ • Non-blocking operations                                     │
├─────────────────────────────────────────────────────────────────┤
│ ASYNCHRONOUS DISADVANTAGES:                                   │
├─────────────────────────────────────────────────────────────────┤
│ • More complex to write                                       │
│ • Requires async/await throughout                            │
│ • Not for CPU-bound tasks                                    │
│ • Learning curve is steeper                                  │
└─────────────────────────────────────────────────────────────────┘
""")

Asynchronous key points:

High concurrency — thousands of connections
Low overhead — no threads
Non-blocking — efficient waiting
Complex — requires async/await

Quick Check: What is asynchronous programming best for? (Answer: High-concurrency I/O applications)

Method Comparison

Threading vs Multiprocessing vs Async

Feature	Threading	Multiprocessing	Async
Memory	Shared	Separate	Shared
GIL	Affected	Not Affected	Not Affected
Best For	I/O-bound	CPU-bound	I/O-bound (high concurrency)
Complexity	Low	Medium	High
Overhead	Low	High	Low
Communication	Shared memory	IPC	Async/await

Comparison summary:

Threading — I/O-bound, simple, shared memory
Multiprocessing — CPU-bound, bypasses GIL
Async — high-concurrency I/O, non-blocking

Quick Check: Which method bypasses the GIL? (Answer: Multiprocessing)

When to Use Which

Choosing the Right Approach

# ============================================================
# DECISION GUIDE
# ============================================================

print("""
┌─────────────────────────────────────────────────────────────────┐
│ USE THREADING WHEN:                                           │
├─────────────────────────────────────────────────────────────────┤
│ 1. Tasks are I/O-bound (network, disk, database)              │
│ 2. Need shared memory                                         │
│ 3. Low overhead is important                                  │
│ 4. Moderate number of concurrent tasks                        │
│                                                                 │
│ Examples: Download manager, web scraper, GUI applications      │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│ USE MULTIPROCESSING WHEN:                                     │
├─────────────────────────────────────────────────────────────────┤
│ 1. Tasks are CPU-bound (calculations)                         │
│ 2. Need to use multiple CPU cores                             │
│ 3. Bypass the GIL                                             │
│ 4. Tasks are independent                                      │
│                                                                 │
│ Examples: ML training, data processing, image processing      │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│ USE ASYNC WHEN:                                               │
├─────────────────────────────────────────────────────────────────┤
│ 1. Very high concurrency (thousands of connections)           │
│ 2. I/O-bound with many small operations                       │
│ 3. Need low overhead                                          │
│ 4. Non-blocking operations                                    │
│                                                                 │
│ Examples: Web servers, chat applications, API gateways       │
└─────────────────────────────────────────────────────────────────┘
""")

# ============================================================
# FLOW CHART
# ============================================================

print("=" * 40)
print("DECISION FLOW CHART")
print("=" * 40)

print("""
        Is task CPU-bound or I/O-bound?
                    |
                    v
        ┌───────────┴───────────┐
        │                       │
    CPU-BOUND              I/O-BOUND
        │                       │
        v                       v
    Is multicore         How many concurrent
    needed?              connections?
        │                       │
        v                       v
    ┌───┴───┐           ┌───────┴───────┐
    │       │           │               │
   Yes     No         Few/Medium        Many
    │       │           │               │
    v       v           v               v
Processes  │        Threading         Async
           │           │               │
           └───────────┴───────────────┘
                    │
                    v
            Consider hybrid approach
""")

Decision guide summary:

CPU-bound → Multiprocessing
I/O-bound (few tasks) → Threading
I/O-bound (many tasks) → Async
Mixed → Hybrid approach

Quick Check: What should you use for CPU-bound tasks? (Answer: Multiprocessing)

Real-World Example

Complete Multi-Tasking Application

# ============================================================
# REAL-WORLD: MULTI-TASKING APPLICATION
# ============================================================

import threading
import multiprocessing
import asyncio
import time
import random

class MultiTaskingApp:
    """Demonstrate all multi-tasking approaches"""
    
    def __init__(self):
        self.results = []
    
    # ============================================================
    # THREADING EXAMPLE
    # ============================================================
    
    def threaded_work(self, worker_id):
        """I/O-bound work using threads"""
        time.sleep(random.uniform(0.3, 0.7))
        result = f"Thread {worker_id}: completed I/O work"
        self.results.append(result)
        return result
    
    def run_threading(self, num_workers=5):
        """Run multiple threads"""
        print("\n1. THREADING:")
        threads = []
        self.results = []
        
        start = time.time()
        for i in range(num_workers):
            t = threading.Thread(target=self.threaded_work, args=(i,))
            threads.append(t)
            t.start()
        
        for t in threads:
            t.join()
        
        end = time.time()
        print(f"   Completed {num_workers} tasks in {end - start:.2f}s")
        print(f"   Results: {len(self.results)}")
    
    # ============================================================
    # MULTIPROCESSING EXAMPLE
    # ============================================================
    
    @staticmethod
    def cpu_work(n):
        """CPU-bound work"""
        result = sum(i*i for i in range(n))
        return f"Process: sum of squares = {result}"
    
    def run_multiprocessing(self, num_workers=4):
        """Run multiple processes"""
        print("\n2. MULTIPROCESSING:")
        
        start = time.time()
        with multiprocessing.Pool(processes=num_workers) as pool:
            numbers = [1000000 + i * 100000 for i in range(num_workers)]
            results = pool.map(self.cpu_work, numbers)
        
        end = time.time()
        print(f"   Completed {num_workers} CPU tasks in {end - start:.2f}s")
        for result in results[:2]:
            print(f"   {result[:50]}...")
    
    # ============================================================
    # ASYNC EXAMPLE
    # ============================================================
    
    async def async_work(self, task_id):
        """Async I/O work"""
        await asyncio.sleep(random.uniform(0.2, 0.5))
        return f"Async {task_id}: completed"
    
    async def run_async(self, num_tasks=10):
        """Run async tasks"""
        print("\n3. ASYNCHRONOUS:")
        
        start = time.time()
        tasks = [self.async_work(i) for i in range(num_tasks)]
        results = await asyncio.gather(*tasks)
        end = time.time()
        
        print(f"   Completed {num_tasks} async tasks in {end - start:.2f}s")
        print(f"   Results: {len(results)}")
    
    # ============================================================
    # RUN ALL
    # ============================================================
    
    def run_all(self):
        """Run all multi-tasking approaches"""
        print("=" * 60)
        print("MULTI-TASKING DEMONSTRATION")
        print("=" * 60)
        
        self.run_threading(5)
        self.run_multiprocessing(4)
        asyncio.run(self.run_async(10))
        
        print("\n" + "=" * 60)
        print("SUMMARY")
        print("=" * 60)
        print("""
┌─────────────────────────────────────────────────────────────────┐
│ Approach       │ Best For                    │ Complexity    │
├─────────────────────────────────────────────────────────────────┤
│ Threading      │ I/O-bound, moderate tasks  │ Low           │
│ Multiprocessing│ CPU-bound, heavy tasks     │ Medium        │
│ Async          │ High-concurrency I/O       │ High          │
└─────────────────────────────────────────────────────────────────┘

Choose based on your specific needs!
""")

# ============================================================
# RUN THE APPLICATION
# ============================================================

if __name__ == "__main__":
    app = MultiTaskingApp()
    app.run_all()

Real-world example key points:

All approaches — demonstrates threading, multiprocessing, async
Different use cases — I/O vs CPU vs high concurrency
Performance comparison — see the differences
Practical — real-world scenarios

Quick Check: What determines which multi-tasking approach to use? (Answer: The type of task - CPU-bound, I/O-bound, or high-concurrency I/O)

Best Practices

Multi-Tasking Best Practices

# ============================================================
# MULTI-TASKING BEST PRACTICES
# ============================================================

print("1. CHOOSE THE RIGHT APPROACH")
print("   - I/O-bound → Threading or Async")
print("   - CPU-bound → Multiprocessing")
print("   - Mixed → Hybrid approach")

print("\n2. USE POOLS FOR MANY TASKS")
print("   - ThreadPoolExecutor for threads")
print("   - ProcessPoolExecutor for processes")
print("   - Async for high concurrency")

print("\n3. HANDLE SHARED DATA CAREFULLY")
print("   - Use locks for threads")
print("   - Use queues for processes")
print("   - Async doesn't share data")

print("\n4. LIMIT RESOURCES")
print("   - Don't create too many threads")
print("   - Don't create too many processes")
print("   - Use appropriate pool sizes")

print("\n5. HANDLE ERRORS")
print("   - Catch exceptions in threads")
print("   - Handle errors in processes")
print("   - Try/except in async tasks")

print("\n6. USE CONTEXT MANAGERS")
print("   - with Pool() as pool")
print("   - with ThreadPoolExecutor()")
print("   - Proper cleanup")

print("\n7. TEST THOROUGHLY")
print("   - Race conditions can be hard to find")
print("   - Test with different loads")
print("   - Use debugging tools")

print("\n8. MONITOR PERFORMANCE")
print("   - Measure execution time")
print("   - Check resource usage")
print("   - Optimize when needed")

Best practices summary:

Choose right approach — based on task type
Use pools — manage resources
Handle shared data — prevent race conditions
Test thoroughly — concurrency bugs are tricky

Quick Check: What should you use to manage many threads? (Answer: ThreadPoolExecutor)

Try It Yourself

Experiment with multi-tasking approaches in the editor below.

Loading Pyodide... 0%

Python Code Editor

# Python Multi Tasking - Practice

print("=" * 40)
print("MULTI TASKING - PRACTICE")
print("=" * 40)

# Simulated Multi-Tasking
class TaskSimulator:
    @staticmethod
    def task(name, delay):
        print(f"  {name}: Starting")
        import time
        time.sleep(delay)
        print(f"  {name}: Completed")
        return f"{name} result"

print("\n1. SINGLE TASKING (Sequential)")
print("-" * 40)

import time
start = time.time()

# Sequential execution
TaskSimulator.task("Task A", 0.3)
TaskSimulator.task("Task B", 0.5)
TaskSimulator.task("Task C", 0.2)

end = time.time()
print(f"Total time: {end - start:.2f}s")

print("\n2. THREADING (Parallel)")
print("-" * 40)

# Simulate threading
class SimThread:
    def __init__(self, target, args):
        self.target = target
        self.args = args
        self.result = None
    
    def start(self):
        import time
        self.result = self.target(*self.args)
    
    def join(self):
        pass

# Simulate running threads
start = time.time()
threads = [
    SimThread(TaskSimulator.task, ("Thread A", 0.3)),
    SimThread(TaskSimulator.task, ("Thread B", 0.5)),
    SimThread(TaskSimulator.task, ("Thread C", 0.2))
]

print("Starting threads in parallel...")
for t in threads:
    t.start()

end = time.time()
print(f"Total time: {end - start:.2f}s")

print("\n3. MULTIPROCESSING (CPU Bound)")
print("-" * 40)

def cpu_task(n):
    import time
    result = sum(i*i for i in range(n))
    time.sleep(0.1)
    return result

# Simulate processes
print("Running CPU tasks in parallel...")
start = time.time()

# Simulate processing
results = [cpu_task(100000) for _ in range(4)]

end = time.time()
print(f"Total time: {end - start:.2f}s")

print("\n4. MULTI-TASKING COMPARISON")
print("-" * 40)

print("""
┌─────────────────────────────────────────────────────────────────┐
│ Approach       │ Best For                    │ Speed         │
├─────────────────────────────────────────────────────────────────┤
│ Single Tasking │ Simple tasks               │ Slowest       │
│ Threading      │ I/O-bound                  │ Faster        │
│ Multiprocessing│ CPU-bound                  │ Fastest       │
└─────────────────────────────────────────────────────────────────┘
""")

print("Multi-tasking makes your program faster!")

========================================
MULTI TASKING - PRACTICE
========================================

1. SINGLE TASKING (Sequential)
----------------------------------------
Task A: Starting
Task A: Completed
Task B: Starting
Task B: Completed
Task C: Starting
Task C: Completed
Total time: 1.01s

2. THREADING (Parallel)
----------------------------------------
Starting threads in parallel...
Thread A: Starting
Thread B: Starting
Thread C: Starting
Thread C: Completed
Thread A: Completed
Thread B: Completed
Total time: 0.01s

3. MULTIPROCESSING (CPU Bound)
----------------------------------------
Running CPU tasks in parallel...
Total time: 0.40s

4. MULTI-TASKING COMPARISON
----------------------------------------
┌─────────────────────────────────────────────────────────────────┐
│ Approach │ Best For │ Speed │
├─────────────────────────────────────────────────────────────────┤
│ Single Tasking │ Simple tasks │ Slowest │
│ Threading │ I/O-bound │ Faster │
│ Multiprocessing│ CPU-bound │ Fastest │
└─────────────────────────────────────────────────────────────────┘

Multi-tasking makes your program faster!

🏆

You've Got It!

You now understand multi-tasking in Python. You know threading, multiprocessing, and async programming, and when to use each.

Quick Quiz

Test what you've learned:

1. What is multi-tasking?

A) Doing one thing at a time B) Doing multiple things at the same time C) Using multiple computers D) Running one program

2. What type of tasks are threads best for?

A) CPU-bound tasks B) I/O-bound tasks C) Memory-bound tasks D) All types of tasks

3. Which approach bypasses the GIL?

A) Threading B) Multiprocessing C) Asynchronous D) None of the above

4. What is asynchronous programming best for?

A) CPU-bound tasks B) High-concurrency I/O C) Simple scripts D) Memory management

5. What should you use for CPU-bound tasks?

A) Threading B) Multiprocessing C) Asynchronous D) Single tasking

Frequently Asked Questions

What is the difference between threading and multiprocessing?

Threading uses threads that share memory and are lightweight. Multiprocessing uses separate processes with their own memory. Threads are for I/O-bound tasks; processes are for CPU-bound tasks.

What is the GIL and why does it matter?

The Global Interpreter Lock (GIL) prevents multiple threads from executing Python bytecode at the same time. This means CPU-bound threads don't get true parallelism. Multiprocessing bypasses the GIL.

What is a common interview question about multi-tasking?

Common questions include: "Explain the difference between threading and multiprocessing," "What is the GIL and how does it affect Python?" "When would you use async over threading?" and "How do you handle race conditions?"

Can I use multiple approaches together?

Yes! You can use a hybrid approach. For example, use processes for CPU-bound work and threads within each process for I/O-bound tasks. This is common in data processing pipelines.

What is the easiest multi-tasking approach?

Threading is generally the easiest to start with. The `threading` module is simple to use and works well for many I/O-bound tasks. For simple parallel tasks, `concurrent.futures.ThreadPoolExecutor` is very beginner-friendly.

Where to Go From Here

Now that you understand multi-tasking, check out these related topics:

Previous: Single Tasking Next: Thread Synchronization →

Python: Multi Tasking

What is Multi Tasking?

Threading

Multiprocessing

Asynchronous

Combined

Multi-Tasking in Action

Threading

Lightweight Concurrent Execution

Multiprocessing

Using Multiple CPU Cores

Asynchronous Programming

Event-Driven Concurrency

Method Comparison

Threading vs Multiprocessing vs Async

When to Use Which

Choosing the Right Approach

Real-World Example

Complete Multi-Tasking Application

Best Practices

Multi-Tasking Best Practices

Try It Yourself

You've Got It!

Quick Quiz

Frequently Asked Questions

What is the difference between threading and multiprocessing?

What is the GIL and why does it matter?

What is a common interview question about multi-tasking?

Can I use multiple approaches together?

What is the easiest multi-tasking approach?

Where to Go From Here

Thread Synchronization

Creating Threads

Threads Assignments

Python

Python: Multi Tasking

What is Multi Tasking?

Threading

Multiprocessing

Asynchronous

Combined

Multi-Tasking in Action

Threading

Lightweight Concurrent Execution

Multiprocessing

Using Multiple CPU Cores

Asynchronous Programming

Event-Driven Concurrency

Method Comparison

Threading vs Multiprocessing vs Async

When to Use Which

Choosing the Right Approach

Real-World Example

Complete Multi-Tasking Application

Best Practices

Multi-Tasking Best Practices

Try It Yourself

You've Got It!

Quick Quiz

Frequently Asked Questions

What is the difference between threading and multiprocessing? ▼

What is the GIL and why does it matter? ▼

What is a common interview question about multi-tasking? ▼

Can I use multiple approaches together? ▼

What is the easiest multi-tasking approach? ▼

Where to Go From Here

Thread Synchronization

Creating Threads

Threads Assignments

What is the difference between threading and multiprocessing?

What is the GIL and why does it matter?

What is a common interview question about multi-tasking?

Can I use multiple approaches together?

What is the easiest multi-tasking approach?