GNU Info

Info Node: (python2.1-lib.info)RLock Objects

(python2.1-lib.info)RLock Objects


Next: Condition Objects Prev: Lock Objects Up: threading
Enter node , (file) or (file)node

RLock Objects
-------------

A reentrant lock is a synchronization primitive that may be acquired
multiple times by the same thread.  Internally, it uses the concepts of
"owning thread" and "recursion level" in addition to the
locked/unlocked state used by primitive locks.  In the locked state,
some thread owns the lock; in the unlocked state, no thread owns it.

To lock the lock, a thread calls its `acquire()' method; this returns
once the thread owns the lock.  To unlock the lock, a thread calls its
`release()' method.  `acquire()'/`release()' call pairs may be nested;
only the final `release()' (i.e. the `release()' of the outermost pair)
resets the lock to unlocked and allows another thread blocked in
`acquire()' to proceed.

`acquire([blocking` = 1'])'
     Acquire a lock, blocking or non-blocking.

     When invoked without arguments: if this thread already owns the
     lock, increment the recursion level by one, and return
     immediately.  Otherwise, if another thread owns the lock, block
     until the lock is unlocked.  Once the lock is unlocked (not owned
     by any thread), then grab ownership, set the recursion level to
     one, and return.  If more than one thread is blocked waiting until
     the lock is unlocked, only one at a time will be able to grab
     ownership of the lock.  There is no return value in this case.

     When invoked with the BLOCKING argument set to true, do the same
     thing as when called without arguments, and return true.

     When invoked with the BLOCKING argument set to false, do not
     block.  If a call without an argument would block, return false
     immediately; otherwise, do the same thing as when called without
     arguments, and return true.

`release()'
     Release a lock, decrementing the recursion level.  If after the
     decrement it is zero, reset the lock to unlocked (not owned by any
     thread), and if any other threads are blocked waiting for the lock
     to become unlocked, allow exactly one of them to proceed.  If
     after the decrement the recursion level is still nonzero, the lock
     remains locked and owned by the calling thread.

     Only call this method when the calling thread owns the lock.  Do
     not call this method when the lock is unlocked.

     There is no return value.


automatically generated by info2www version 1.2.2.9