Open In App
Related Articles

Synchronization by using Semaphore in Python

Improve Article
Save Article
Like Article

In Lock and RLock, at a time only one Thread is allowed to execute but sometimes our requirement is to execute a particular number of Threads at a time.   

Suppose we have to allow at a time 10 members to access the Database and only 4 members are allowed to access Network Connection. To handle such types of requirements we can not use Lock and RLock concept and here we should go for Semaphore. Semaphore can be used to limit the access to the shared resources with limited capacity. It is an advanced part of synchronization.

Create an object of Semaphore: 

object_name = Semaphore(count)

Here ‘count’ is the number of Threads allowed to access simultaneously. The default value of count is 1.

When a Thread executes acquire() method then the value of “count” variable will be decremented by 1 and whenever a Thread executes release() method then the value of “count” variable will be incremented by 1. i.e whenever acquire() method will be called the value of count variable will be decremented and whenever release() method will be called the value of “count” variable will be incremented. 

Way to create an object of Semaphore :  

Case 1 :                                                                                                                                                                            


In this case, by default value of the count variable is 1 due to which only one thread is allowed to access. It is exactly the same as the Lock concept.

Case 2


In this case, a Semaphore object can be accessed by n Threads at a time. The remaining Threads have to wait until releasing the semaphore.

Executable code of Semaphore : 


# importing the modules
from threading import *         
import time        
# creating thread instance where count = 3
obj = Semaphore(3)        
# creating instance
def display(name):    
    # calling acquire method
    for i in range(5):
        print('Hello, ', end = '')
        # calling release method
# creating multiple thread 
t1 = Thread(target = display , args = ('Thread-1',))
t2 = Thread(target = display , args = ('Thread-2',))
t3 = Thread(target = display , args = ('Thread-3',))
t4 = Thread(target = display , args = ('Thread-4',))
t5 = Thread(target = display , args = ('Thread-5',))
# calling the threads 



Here in the above example first we created an instance of Semaphore Class where the value of “count” is 3 it means that Semaphore Object can be accessed by 3 Threads at a time. Now we have created display() method which will print the Thread name 5 times. Now we created 5 threads and now whenever we call start() method at that time 3 Threads are allowed to access Semaphore objects and hence 3 Threads are allowed to execute display() method at a time but in this example whenever we will execute we will get irregular output because 3 Threads are executing display() method at a time.                     

Whether you're preparing for your first job interview or aiming to upskill in this ever-evolving tech landscape, GeeksforGeeks Courses are your key to success. We provide top-quality content at affordable prices, all geared towards accelerating your growth in a time-bound manner. Join the millions we've already empowered, and we're here to do the same for you. Don't miss out - check it out now!

Last Updated : 11 Oct, 2020
Like Article
Save Article
Similar Reads
Related Tutorials