GNU Info

(python2.1-lib.info)Lock Objects

---

Next: RLock Objects Prev: threading Up: threading

---

Enter node , (file) or (file)node

Lock Objects
------------

A primitive lock is a synchronization primitive that is not owned by a
particular thread when locked.  In Python, it is currently the lowest
level synchronization primitive available, implemented directly by the
`thread' extension module.

A primitive lock is in one of two states, "locked" or "unlocked".  It
is created in the unlocked state.  It has two basic methods,
`acquire()' and `release()'.  When the state is unlocked, `acquire()'
changes the state to locked and returns immediately.  When the state is
locked, `acquire()' blocks until a call to `release()' in another
thread changes it to unlocked, then the `acquire()' call resets it to
locked and returns.  The `release()' method should only be called in the
locked state; it changes the state to unlocked and returns immediately.
When more than one thread is blocked in `acquire()' waiting for the
state to turn to unlocked, only one thread proceeds when a `release()'
call resets the state to unlocked; which one of the waiting threads
proceeds is not defined, and may vary across implementations.

All methods are executed atomically.

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

     When invoked without arguments, block until the lock is unlocked,
     then set it to locked, and return.  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.

     When the lock is locked, reset it to unlocked, and return.  If any
     other threads are blocked waiting for the lock to become unlocked,
     allow exactly one of them to proceed.

     Do not call this method when the lock is unlocked.

     There is no return value.