Synchronizing Threads

In Python, when multiple threads are working concurrently with shared resources, it’s important to synchronize their access to maintain data integrity and program correctness. Synchronizing threads in python can be achieved using various synchronization primitives provided by the threading module, such as locks, conditions, semaphores, and barriers to control access to shared resources and coordinate the execution of multiple threads.

In this tutorial, we’ll learn about various synchronization primitives provided by Python’s threading module.

Thread Synchronization using Locks

The lock object in the Python’s threading module provide the simplest synchronization primitive. They allow threads to acquire and release locks around critical sections of code, ensuring that only one thread can execute the protected code at a time.

A new lock is created by calling the Lock() method, which returns a lock object. The lock can be acquired using the acquire(blocking) method, which force the threads to run synchronously. The optional blocking parameter enables you to control whether the thread waits to acquire the lock and released using the release() method.

Example

The following example demonstrates how to use locks (the threading.Lock() method) to synchronize threads in Python, ensuring that multiple threads access shared resources safely and correctly.

Open Compiler

import threading

counter =10defincrement(theLock, N):global counter
   for i inrange(N):
      theLock.acquire()
      counter +=1
      theLock.release()

lock = threading.Lock()
t1 = threading.Thread(target=increment, args=[lock,2])
t2 = threading.Thread(target=increment, args=[lock,10])
t3 = threading.Thread(target=increment, args=[lock,4])

t1.start()
t2.start()
t3.start()# Wait for all threads to completefor thread in(t1, t2, t3):
   thread.join()print("All threads have completed")print("The Final Counter Value:", counter)

Output

When the above code is executed, it produces the following output −

All threads have completed
The Final Counter Value: 26

Condition Objects for Synchronizing Python Threads

Condition variables enable threads to wait until notified by another thread. They are useful for providing communication between the threads. The wait() method is used to block a thread until it is notified by another thread through notify() or notify_all().

Example

This example demonstrates how Condition objects can synchronize threads using the notify() and wait() methods.

Open Compiler

import threading

counter =0# Consumer functiondefconsumer(cv):global counter
   with cv:print("Consumer is waiting")
      cv.wait()# Wait until notified by incrementprint("Consumer has been notified. Current Counter value:", counter)# increment functiondefincrement(cv, N):global counter
   with cv:print("increment is producing items")for i inrange(1, N +1):
         counter += i  # Increment counter by i# Notify the consumer 
      cv.notify()print("Increment has finished")# Create a Condition object
cv = threading.Condition()# Create and start threads
consumer_thread = threading.Thread(target=consumer, args=[cv])
increment_thread = threading.Thread(target=increment, args=[cv,5])

consumer_thread.start()
increment_thread.start()

consumer_thread.join()
increment_thread.join()print("The Final Counter Value:", counter)

Output

On executing the above program, it will produce the following output −

Consumer is waiting
increment is producing items
Increment has finished
Consumer has been notified. Current Counter value: 15
The Final Counter Value: 15

Learn Python in-depth with real-world projects through our Python certification course. Enroll and become a certified expert to boost your career.