def do_release_read_lock(self):
self.condition.acquire()
try:
self.async -= 1
# check if we are the last asynchronous reader thread
# out the door.
if self.async == 0:
# yes. so if a sync operation is waiting, notifyAll to wake
# it up
if self.current_sync_operation is not None:
self.condition.notifyAll()
elif self.async < 0:
raise LockError("Synchronizer error - too many "
"release_read_locks called")
def acquire_write_lock(self, wait=True):
state = self.state
if state.reading:
raise LockError("lock is in reading state")
if state.reentrantcount == 0:
x = self.do_acquire_write_lock(wait)
if (wait or x):
state.reentrantcount += 1
state.writing = True
return x
elif state.writing:
state.reentrantcount += 1
return True
def do_release_write_lock(self):
self.condition.acquire()
try:
if self.current_sync_operation is not _threading.currentThread():
raise LockError("Synchronizer error - current thread doesnt "
"have the write lock")
# reset the current sync operation so
# another can get it
self.current_sync_operation = None
# tell everyone to get ready
self.condition.notifyAll()
finally:
# everyone go !!
self.condition.release()
class ConditionSynchronizer(SynchronizerImpl):
"""a synchronizer using a Condition.
this synchronizer is based on threading.Lock() objects and
therefore must be shared among threads, so it is also threadsafe.
the "state" variable referenced by the base SynchronizerImpl class
is turned into a thread local, and all the do_XXXX methods are synchronized
on the condition object.
The Synchronizer container will maintain a registry of ConditionSynchronizer
objects keyed to the name of the synchronizer.
"""
def __init__(self, identifier):
self.tlocalstate = util.ThreadLocal(creator=lambda: SyncState())
# counts how many asynchronous methods are executing
self. async = 0
# pointer to thread that is the current sync operation
self.current_sync_operation = None
# condition object to lock on
self.condition = _threading.Condition(_threading.Lock())
state = property(lambda self: self.tlocalstate())
def do_acquire_read_lock(self, wait=True):
self.condition.acquire()
# see if a synchronous operation is waiting to start
# or is already running, in which case we wait (or just
# give up and return)
if wait:
while self.current_sync_operation is not None:
self.condition.wait()
else:
if self.current_sync_operation is not None:
self.condition.release()
return False
self. async += 1
self.condition.release()
if not wait: return True
def do_release_read_lock(self):
self.condition.acquire()
self. async -= 1
# check if we are the last asynchronous reader thread
# out the door.
if self. async == 0:
# yes. so if a sync operation is waiting, notifyAll to wake
# it up
if self.current_sync_operation is not None:
self.condition.notifyAll()
elif self. async < 0:
raise LockError(
"Synchronizer error - too many release_read_locks called")