Python – Thread Synchronization

Introduction

Thread synchronization is essential in multithreaded programming to prevent race conditions and ensure data integrity when multiple threads access shared resources. Python provides several synchronization primitives in the threading module, such as Locks, RLocks, Semaphores, Conditions, and Events.

Synchronization Primitives

1. Lock

A Lock is the simplest form of synchronization primitive. It ensures that only one thread can access a resource at a time.

Example

import threading

lock = threading.Lock()
shared_resource = 0

def increment():
    global shared_resource
    for _ in range(1000000):
        with lock:
            shared_resource += 1

# Create threads
threads = [threading.Thread(target=increment) for _ in range(2)]

# Start threads
for thread in threads:
    thread.start()

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

print(f"Final value of shared_resource: {shared_resource}")

Output

Final value of shared_resource: 2000000

2. RLock (Reentrant Lock)

An RLock (Reentrant Lock) allows a thread to acquire the same lock multiple times without causing a deadlock.

Example

import threading

rlock = threading.RLock()
shared_resource = 0

def increment():
    global shared_resource
    for _ in range(1000000):
        with rlock:
            shared_resource += 1

# Create threads
threads = [threading.Thread(target=increment) for _ in range(2)]

# Start threads
for thread in threads:
    thread.start()

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

print(f"Final value of shared_resource: {shared_resource}")

Output

Final value of shared_resource: 2000000

3. Semaphore

A Semaphore controls access to a resource with a fixed number of permits.

Example

import threading
import time

semaphore = threading.Semaphore(2)

def access_resource(thread_id):
    with semaphore:
        print(f"Thread {thread_id} accessing resource")
        time.sleep(2)
        print(f"Thread {thread_id} releasing resource")

# Create threads
threads = [threading.Thread(target=access_resource, args=(i,)) for i in range(4)]

# Start threads
for thread in threads:
    thread.start()

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

print("All threads have finished execution.")

Output

Thread 0 accessing resource
Thread 1 accessing resource
Thread 0 releasing resource
Thread 1 releasing resource
Thread 2 accessing resource
Thread 3 accessing resource
Thread 2 releasing resource
Thread 3 releasing resource
All threads have finished execution.

4. Condition

A Condition allows threads to wait for certain conditions to be met before continuing execution. It is often used in conjunction with a Lock or RLock.

Example

import threading

condition = threading.Condition()
queue = []

def consumer():
    with condition:
        condition.wait()  # Wait for the condition to be notified
        while queue:
            item = queue.pop(0)
            print(f"Consumed: {item}")

def producer():
    with condition:
        for i in range(5):
            queue.append(i)
            print(f"Produced: {i}")
        condition.notify_all()  # Notify all waiting threads

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

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

# Wait for all threads to complete
consumer_thread.join()
producer_thread.join()

print("All threads have finished execution.")

Output

Produced: 0
Produced: 1
Produced: 2
Produced: 3
Produced: 4
Consumed: 0
Consumed: 1
Consumed: 2
Consumed: 3
Consumed: 4
All threads have finished execution.

5. Event

An Event is a simple synchronization primitive that allows one thread to signal one or more other threads that an event has occurred.

Example

import threading
import time

event = threading.Event()

def waiter():
    print("Waiting for event to be set")
    event.wait()  # Wait for the event to be set
    print("Event has been set!")

def setter():
    time.sleep(2)
    print("Setting the event")
    event.set()

# Create threads
waiter_thread = threading.Thread(target=waiter)
setter_thread = threading.Thread(target=setter)

# Start threads
waiter_thread.start()
setter_thread.start()

# Wait for all threads to complete
waiter_thread.join()
setter_thread.join()

print("All threads have finished execution.")

Output

Waiting for event to be set
Setting the event
Event has been set!
All threads have finished execution.

Conclusion

Thread synchronization is crucial for managing concurrent access to shared resources and preventing race conditions in multithreaded programs. Python’s threading module provides several synchronization primitives such as Locks, RLocks, Semaphores, Conditions, and Events to help you manage thread synchronization effectively. Understanding these primitives and how to use them will enable you to write robust and efficient multithreaded applications in Python.