> # The way I would like to do it, so we have two different instances of
> the same variable, and only # one function can access it at a time. If a
> function comes to that variable and finds a lock on it, # it will wait
> until the lock is released. And the variable happens to be a queue
Hi Tino,
One way to do this is to add a level of indirection.
##############################################
class LockedVariable:
def __init__(self, val):
self.val = val
self.internal_lock = RLock()
def acquire(self):
self.internal_lock.acquire()
def release(self):
self.internal_lock.release()
def with_lock(locked_variable, function):
locked_variable.acquire()
try:
return function(locked_variable.val)
finally:
locked_variable.release()
##############################################
The idea is that this allows us to pair up values with individual locks.
There's nothing that restricts us to having one lock per program.
If you have some experience with treating functions as values, the last
function, with_lock(), might be useful. It's meant to be used as:
#########################################################
## Pseudocode
def function_using_some_locked_resource(locked_resource):
def actual_work(val):
## ...
with_lock(locked_variable, actual_work)
#########################################################
with_lock() here tries to capture the mutual-exclusion abstraction, and
might make programs a little less error prone: we'll never forget to
release the lock, because it handles both resource acquiring and
releasing.
_______________________________________________
Tutor maillist - Tutor@python.org
http://mail.python.org/mailman/listinfo/tutor
