Python - Synchronizing Threads

Hello there, future Python wizards! Today, we're going to embark on an exciting journey into the world of thread synchronization. Imagine you're conducting an orchestra where each musician is a thread, and you need to make sure they all play in harmony. That's essentially what thread synchronization is all about in programming!

Thread Synchronization using Locks

Let's start with the most basic tool in our synchronization toolkit: locks. Think of a lock as a "do not disturb" sign on a hotel room door. When a thread acquires a lock, it's like putting that sign up, telling other threads, "Hey, I'm busy in here!"

Here's a simple example to illustrate this concept:

import threading
import time

# Shared resource
counter = 0

# Create a lock
lock = threading.Lock()

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

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

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

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

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

In this example, we have a shared resource counter that two threads are trying to increment. Without the lock, we might end up with a race condition, where both threads try to increment the counter simultaneously, potentially leading to incorrect results.

By using lock.acquire() before modifying the counter and lock.release() after, we ensure that only one thread can increment the counter at a time. It's like passing a baton in a relay race – only the thread holding the baton (lock) can run (modify the shared resource).

Condition Objects for Synchronizing Python Threads

Now, let's level up our synchronization game with Condition objects. These are like sophisticated traffic lights for our threads, allowing more complex coordination.

Here's an example of a producer-consumer scenario using a Condition object:

import threading
import time
import random

# Shared buffer
buffer = []
MAX_SIZE = 5

# Create a condition object
condition = threading.Condition()

def producer():
    global buffer
    while True:
        with condition:
            while len(buffer) == MAX_SIZE:
                print("Buffer full, producer is waiting...")
                condition.wait()
            item = random.randint(1, 100)
            buffer.append(item)
            print(f"Produced: {item}")
            condition.notify()
        time.sleep(random.random())

def consumer():
    global buffer
    while True:
        with condition:
            while len(buffer) == 0:
                print("Buffer empty, consumer is waiting...")
                condition.wait()
            item = buffer.pop(0)
            print(f"Consumed: {item}")
            condition.notify()
        time.sleep(random.random())

# Create producer and consumer threads
producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)

# Start the threads
producer_thread.start()
consumer_thread.start()

# Let it run for a while
time.sleep(10)

In this example, we have a producer adding items to a buffer and a consumer removing items from it. The Condition object helps coordinate their actions:

• The producer waits when the buffer is full.
• The consumer waits when the buffer is empty.
• They notify each other when it's safe to proceed.

It's like a well-choreographed dance, with the Condition object as the choreographer!

Synchronizing threads using the join() Method

The join() method is like telling one thread to wait for another to finish its performance before taking the stage. It's a simple yet powerful way to synchronize threads.

Here's an example:

import threading
import time

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

# Create threads
thread1 = threading.Thread(target=worker, args=("Thread 1", 2))
thread2 = threading.Thread(target=worker, args=("Thread 2", 4))

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

# Wait for thread1 to finish
thread1.join()
print("Main thread waiting after thread1")

# Wait for thread2 to finish
thread2.join()
print("Main thread waiting after thread2")

print("All threads have finished!")

In this example, the main thread starts two worker threads and then waits for each to finish using join(). It's like a parent waiting for their children to finish their homework before serving dinner!

Additional Synchronization Primitives

Python offers several other tools for thread synchronization. Let's take a quick look at some of them:

Primitive	Description	Use Case
Semaphore	Allows a limited number of threads to access a resource	Managing a pool of database connections
Event	Allows one thread to signal an event to other threads	Signaling that a task is complete
Barrier	Allows multiple threads to wait until all reach a certain point	Synchronizing the start of a race

Here's a quick example using a Semaphore:

import threading
import time

# Create a semaphore that allows 2 threads at a time
semaphore = threading.Semaphore(2)

def worker(name):
    with semaphore:
        print(f"{name} acquired the semaphore")
        time.sleep(1)
        print(f"{name} released the semaphore")

# Create and start 5 threads
threads = []
for i in range(5):
    thread = threading.Thread(target=worker, args=(f"Thread {i}",))
    threads.append(thread)
    thread.start()

# Wait for all threads to finish
for thread in threads:
    thread.join()

print("All threads have finished!")

In this example, the semaphore acts like a bouncer at a club, only allowing two threads in at a time. It's perfect for situations where you need to limit access to a scarce resource!

And there you have it, folks! We've explored the fascinating world of thread synchronization in Python. Remember, like conducting an orchestra or choreographing a dance, synchronizing threads is all about coordination and timing. With these tools in your programming toolkit, you're well on your way to creating harmonious, multi-threaded Python programs. Keep practicing, stay curious, and happy coding!

Credits: Image by storyset