59. Thread Synchronization with Locks

Here are some Python code snippets that demonstrate how to use thread locks for synchronization in multi-threading:

---

1. Basic Thread Synchronization with Lock

This example uses a lock to ensure that only one thread can access a critical section at a time.

import threading

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

def increment():
    global counter
    with lock:  # Acquire the lock
        temp = counter
        temp += 1
        counter = temp

threads = []
for _ in range(100):
    thread = threading.Thread(target=increment)
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

print(f"Counter value: {counter}")  # Output: 100

In this code, the increment function updates the global counter variable. The lock is used to ensure that only one thread can modify counter at a time.

---

2. Using Lock with a Shared Resource

In this example, we have multiple threads that increment and decrement a shared resource safely using a lock.

import threading

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

def increment():
    global shared_resource
    with lock:
        shared_resource += 1

def decrement():
    global shared_resource
    with lock:
        shared_resource -= 1

threads = []
for _ in range(50):
    thread = threading.Thread(target=increment)
    threads.append(thread)
    thread.start()

for _ in range(30):
    thread = threading.Thread(target=decrement)
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

print(f"Shared resource value: {shared_resource}")  # Output will depend on thread timing

The lock ensures that both increment and decrement functions safely modify the shared resource without any race conditions.

---

3. Reentrant Lock (RLock) Example

A reentrant lock allows a thread to lock the same lock multiple times. Here's how to use an RLock for nested locking scenarios.

import threading

# Shared resource
counter = 0
rlock = threading.RLock()

def increment():
    global counter
    with rlock:
        counter += 1
        print(f"Counter after increment: {counter}")
        # Simulate nested locking
        with rlock:
            counter += 1
            print(f"Counter after nested increment: {counter}")

threads = []
for _ in range(5):
    thread = threading.Thread(target=increment)
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

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

In this example, the RLock allows the same thread to lock the resource multiple times without causing a deadlock.

---

4. Deadlock Avoidance Using Locks

Deadlock can occur when two or more threads wait for each other to release a resource. This example shows how to avoid deadlock using two locks.

import threading

# Shared resources
lock1 = threading.Lock()
lock2 = threading.Lock()

def thread1():
    with lock1:
        print("Thread 1 acquired lock 1")
        with lock2:
            print("Thread 1 acquired lock 2")

def thread2():
    with lock2:
        print("Thread 2 acquired lock 2")
        with lock1:
            print("Thread 2 acquired lock 1")

# Start the threads
t1 = threading.Thread(target=thread1)
t2 = threading.Thread(target=thread2)

t1.start()
t2.start()

t1.join()
t2.join()

By acquiring the locks in the same order (lock1 first, then lock2), you avoid deadlock.

---

5. Locking with Condition Variables

A Condition is used to synchronize threads by having them wait for a particular condition to be met. This example shows how to use a condition with a lock.

import threading
import time

condition = threading.Condition()

def waiter():
    with condition:
        print("Waiting for signal...")
        condition.wait()  # Wait until notified
        print("Received signal!")

def notifier():
    time.sleep(2)
    with condition:
        print("Notifying all threads")
        condition.notify_all()  # Notify waiting threads

# Create threads
thread1 = threading.Thread(target=waiter)
thread2 = threading.Thread(target=waiter)
notifier_thread = threading.Thread(target=notifier)

thread1.start()
thread2.start()
notifier_thread.start()

thread1.join()
thread2.join()
notifier_thread.join()

In this example, two threads wait for a condition to be met, and one thread notifies them after a delay.

---

6. Using Lock for Thread-safe Queue

A lock can be used to ensure that threads can safely interact with a shared queue.

import threading
import queue

q = queue.Queue()
lock = threading.Lock()

def producer():
    with lock:
        for i in range(5):
            q.put(i)
            print(f"Produced {i}")

def consumer():
    with lock:
        while not q.empty():
            item = q.get()
            print(f"Consumed {item}")

# Create threads
prod_thread = threading.Thread(target=producer)
cons_thread = threading.Thread(target=consumer)

prod_thread.start()
cons_thread.start()

prod_thread.join()
cons_thread.join()

In this example, a lock is used to ensure that the producer and consumer threads do not access the queue simultaneously.

---

7. Using Lock to Protect File Writing

A lock can be used to protect file writing in a multi-threaded environment.

import threading

lock = threading.Lock()

def write_to_file():
    with lock:
        with open("output.txt", "a") as f:
            f.write("Thread-safe write operation\n")

threads = []
for _ in range(5):
    thread = threading.Thread(target=write_to_file)
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

print("File written successfully.")

In this example, multiple threads are safely writing to the same file using a lock.

---

8. Locking with Thread Pool Executor

The ThreadPoolExecutor can be combined with locks for efficient thread management in tasks requiring synchronization.

import threading
from concurrent.futures import ThreadPoolExecutor

counter = 0
lock = threading.Lock()

def increment():
    global counter
    with lock:
        counter += 1

with ThreadPoolExecutor(max_workers=10) as executor:
    for _ in range(100):
        executor.submit(increment)

print(f"Counter value: {counter}")  # Output: 100

This example uses a thread pool to manage multiple threads and ensures synchronization via a lock.

---

9. Locking with Timer Thread

This example shows how a timer thread can be synchronized using a lock.

import threading
import time

lock = threading.Lock()

def timer_function():
    with lock:
        print("Timer started")
        time.sleep(3)
        print("Timer ended")

# Start the timer thread
timer_thread = threading.Thread(target=timer_function)
timer_thread.start()
timer_thread.join()

The lock ensures that the timer thread's output is thread-safe and prevents race conditions with other threads.

---

10. Read-Write Lock Simulation

This example simulates a read-write lock using a lock to control multiple readers and a single writer.

import threading

read_lock = threading.Lock()
write_lock = threading.Lock()

def reader():
    with read_lock:
        print("Reading data...")

def writer():
    with write_lock:
        print("Writing data...")

# Create threads
reader_threads = [threading.Thread(target=reader) for _ in range(3)]
writer_thread = threading.Thread(target=writer)

for thread in reader_threads:
    thread.start()

writer_thread.start()

for thread in reader_threads:
    thread.join()

writer_thread.join()

In this example, multiple reader threads can run concurrently, but the writer thread is given exclusive access.

---

These examples demonstrate various ways to use locks in Python's threading module to ensure thread synchronization and prevent race conditions.