Python - Multithreading

Hello there, future Python wizards! Today, we're going to embark on an exciting journey into the world of multithreading in Python. Don't worry if you're new to programming; I'll be your friendly guide, and we'll explore this topic step by step. So, grab your virtual wands (keyboards), and let's dive in!

What is Multithreading?

Before we start casting spells with Python threads, let's understand what multithreading is all about. Imagine you're a chef in a busy kitchen. If you're cooking alone, you can only do one task at a time – chop vegetables, then boil water, then fry the meat. But what if you had multiple hands that could do different tasks simultaneously? That's essentially what multithreading does for our programs!

Multithreading allows a program to execute multiple tasks concurrently within a single process. It's like having multiple chefs (threads) working together in the same kitchen (process) to prepare a delicious meal (program output) faster and more efficiently.

Comparison with Processes

Now, you might be wondering, "But teacher, I've heard about processes too. How are threads different?" Great question! Let's break it down:

1. Resource Usage: Threads are like siblings sharing a room (memory space), while processes are like neighbors with separate houses. Threads are lighter and share resources, making them more efficient for certain tasks.

2. Communication: Threads can chat easily by sharing variables, but processes need to use special "phones" (inter-process communication) to talk to each other.

3. Overhead: Creating and managing threads is usually faster and requires less system resources compared to processes.

4. Complexity: While threads can make your program faster, they also introduce complexity. It's like juggling – fun and efficient when done right, but you might drop a ball if you're not careful!

Thread Handling Modules in Python

Python, being the generous language it is, provides us with multiple modules to work with threads. The two main ones are:

1. threading: This is the high-level interface for working with threads. It's like the friendly wizard's apprentice who does most of the heavy lifting for you.

2. _thread: This is the low-level interface. It's like the ancient spell book – powerful but requires more expertise to use correctly.

For our magical journey today, we'll focus on the threading module, as it's more beginner-friendly and widely used.

Starting a New Thread

Alright, let's cast our first thread spell! Here's how we create and start a new thread:

import threading
import time

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

# Create a new thread
thread1 = threading.Thread(target=print_numbers)

# Start the thread
thread1.start()

# Main thread continues to execute
for i in range(5):
    time.sleep(1)
    print(f"Main thread: {i}")

# Wait for thread1 to finish
thread1.join()

print("All done!")

Let's break down this magical incantation:

1. We import the threading and time modules.
2. We define a function print_numbers() that will be executed by our thread.
3. We create a new thread object, specifying the function it should run.
4. We start the thread using the start() method.
5. The main thread continues to execute its own loop.
6. We use join() to wait for our thread to finish before ending the program.

When you run this, you'll see the numbers from both threads interleaved, demonstrating concurrent execution!

Synchronizing Threads

Now, imagine our chef helpers trying to use the same knife at the same time – chaos, right? This is where thread synchronization comes in. We use locks to ensure that only one thread can access a shared resource at a time.

Here's an example:

import threading
import time

# Shared resource
counter = 0
lock = threading.Lock()

def increment_counter():
    global counter
    for _ in range(100000):
        lock.acquire()
        counter += 1
        lock.release()

# Create two threads
thread1 = threading.Thread(target=increment_counter)
thread2 = threading.Thread(target=increment_counter)

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

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

print(f"Final counter value: {counter}")

In this example, we use a lock to ensure that only one thread can increment the counter at a time, preventing race conditions.

Multithreaded Priority Queue

Last but not least, let's look at a practical application of multithreading – a priority queue. Imagine a hospital emergency room where patients are treated based on the severity of their condition, not just their arrival time.

import threading
import queue
import time
import random

# Create a priority queue
task_queue = queue.PriorityQueue()

def worker():
    while True:
        priority, task = task_queue.get()
        print(f"Processing task: {task} (Priority: {priority})")
        time.sleep(random.uniform(0.1, 0.5))  # Simulate work
        task_queue.task_done()

# Create and start worker threads
for _ in range(3):
    thread = threading.Thread(target=worker, daemon=True)
    thread.start()

# Add tasks to the queue
for i in range(10):
    priority = random.randint(1, 5)
    task = f"Task {i}"
    task_queue.put((priority, task))

# Wait for all tasks to be completed
task_queue.join()
print("All tasks completed!")

This example demonstrates how multiple threads can work together to process tasks from a priority queue efficiently.

Conclusion

Congratulations, young Pythonistas! You've just taken your first steps into the magical realm of multithreading. Remember, with great power comes great responsibility – use threads wisely, and they'll make your programs faster and more efficient.

Here's a quick reference table of the main threading methods we've covered:

Method	Description
Thread(target=function)	Creates a new thread to run the specified function
start()	Starts the thread's activity
join()	Waits for the thread to complete
Lock()	Creates a lock for thread synchronization
acquire()	Acquires a lock
release()	Releases a lock

Keep practicing, stay curious, and soon you'll be orchestrating threads like a true Python maestro! Happy coding!

Credits: Image by storyset