Overview:
- A semaphore is a synchronization construct.
- Semaphore provides threads with synchronized access to a limited number of resources.
- A semaphore is just a variable. The variable reflects the number of currently available resources. For example, a parking lot with a display of number of available slots on a specific level of a shopping mall is a semaphore.
- The value of semaphore cannot go less than zero and greater then the total number of the available resources.
- The semaphore is associated with two operations – acquire and release.
- When one of the resources synchronized by a semaphore is "acquired" by a thread, the value of the semaphore is decremented.
- When one of the resources synchronized by a semaphore is "released" by a thread the value of the semaphore is incremented.
- The Dutch computer scientist Edsger Dijkstra invented the concept of semaphore.
- Dijkstra named the two operations on a semaphore acquire and release as p and v using the first letter of the Dutch words proberen and vehogen.
- The word proberen means test and vehogen means increment in Dutch.
Semaphores in Python:
- The Semaphore class of the Python threading module implements the concept of semaphore.
- It has a constructor and two methods acquire() and release().
- The acquire() method decreases the semaphore count if the count is greater than zero. Else it blocks till the count is greater than zero.
- The release() method increases the semaphore count and wakes up one of the threads waiting on the semaphore.
Example:
|
# An example python program using semaphore provided by the python threading module import threading import time
parkRequests = 0 removeRequests = 0
parked = 0 removed = 0
parkedLock = threading.Lock() removedLock = threading.Lock()
availbleParkings = threading.Semaphore(10)
def ParkCar(): availbleParkings.acquire() global parkedLock parkedLock.acquire()
global parked parked = parked+1 parkedLock.release()
print("Parked: %d"%(parked))
def RemoveCar(): availbleParkings.release() global removedLock removedLock.acquire()
global removed removed = removed+1 removedLock.release() print("Removed: %d"%(removed))
# Thread that simulates the entry of cars into the parking lot def parkingEntry(): # Creates multiple threads inside to simulate cars that are parked while(True): time.sleep(1) incomingCar = threading.Thread(target=ParkCar) incomingCar.start()
global parkRequests parkRequests = parkRequests+1 print("Parking Requests: %d"%(parkRequests))
# Thread that simulates the exit of cars from the parking lot def parkingExit(): # Creates multiple threads inside to simulate cars taken out from the parking lot while(True): time.sleep(3) outgoingCar = threading.Thread(target=RemoveCar) outgoingCar.start()
global removeRequests removeRequests = removeRequests+1 print("Remove Requests: %d"%(removeRequests))
# Start the parking eco-system parkingEntryThread = threading.Thread(target=parkingEntry) parkingExitThread = threading.Thread(target=parkingExit)
parkingEntryThread.start() parkingExitThread.start() |
Output:
|
Parked: 14 Parking Requests: 14 Removed: 5 Remove Requests: 5 Parked: 15 Parking Requests: 15 Parking Requests: 16 Parking Requests: 17 Removed: 6 Remove Requests: 6 Parked: 16 Parking Requests: 18 Parking Requests: 19 Parking Requests: 20 Removed: 7 Remove Requests: 7 Parked: 17 Parking Requests: 21 Parking Requests: 22 Parking Requests: 23 Removed: 8 Parked: 18 Remove Requests: 8 Parking Requests: 24 |