Overview
- A race condition is a scenario in which, multiple threads compete for a resource. A resource could be a Python variable, a file object and so on.
- When multiple threads access the same resource for example a global variable, it could lead to data inconsistencies as threads read / write order is not serialised.
- Here is a sample Python program that does not take care of race conditions. The final value of variable NumberOfVisits may not be consistent during each execution of the program as access to the variable NumberOfVisits is not serialized against race conditions that could arise from multiple threads.
Example 1 - Without Lock
import threading
import random
import time
NumberOfVisits = 0
ThreadList = []
ThreadCount = 20
def AddVistor():
# Sleep for random seconds
randomSeconds = random.random()
time.sleep(randomSeconds)
#Increment Counter
global NumberOfVisits
SomeVar = NumberOfVisits
SomeVar = SomeVar +1
NumberOfVisits = SomeVar
#Create several threads
for index in range(ThreadCount):
ThreadInstance = threading.Thread(target=AddVistor())
ThreadList.append(ThreadInstance)
ThreadInstance.start()
for index in range(ThreadCount):
ThreadList[index].join()
# print the final count
print(NumberOfVisits)Example 2 - With Lock
- A lock object comes handy here. Any instance that has acquired a lock, makes its state not modifiable by concurrent threads. Once a Python object acquires a lock by calling the acquire() method of the Lock instance, another thread can not modify the object state till the lock is released by calling the release() method.
- An example Python program that effectively guards a counter variable against race conditions is given here.
import threading
import random
import time
class SafeCounter(object):
def __init__(self):
self.lock = threading.Lock() # Create a lock object. Initial state is unlocked state
self.countValue = 0
def CounterIncrease(self):
try:
# Acquire a lock before modifying the object state
self.lock.acquire()
# Increment the counter value
self.countValue = self.countValue + 1
finally:
# Release the lock in any case
self.lock.release()
def SessionThread(CounterObject):
# Increase the count after random duration
for index in range(ThreadCount):
randomSeconds = random.random()
time.sleep(randomSeconds)
CounterObject.CounterIncrease()
ThreadCount = 20
# Create many session threads
CounterObject = SafeCounter()
threading.Thread(target=SessionThread(CounterObject))
print(CounterObject.countValue)- In the above Python program SafeCounter acquires a lock on each increment of its counter variable countValue.
- The acquired lock is released after the counter is incremented. After the lock is released any other thread can access the countValue.
- While the lock is in acquired state, any other thread that accesses the countValue will be blocked.
- Access is provided only if a thread acquires a lock for which multiple threads may complete upon the release of the lock by the thread that is already holding the lock.