GNU Info

(python2.1-lib.info)Semaphore Objects

---

Next: Event Objects Prev: Condition Objects Up: threading

---

Enter node , (file) or (file)node

Semaphore Objects
-----------------

This is one of the oldest synchronization primitives in the history of
computer science, invented by the early Dutch computer scientist Edsger
W. Dijkstra (he used `P()' and `V()' instead of `acquire()' and
`release()').

A semaphore manages an internal counter which is decremented by each
`acquire()' call and incremented by each `release()' call.  The counter
can never go below zero; when `acquire()' finds that it is zero, it
blocks, waiting until some other thread calls `release()'.

`Semaphore([value])'
     The optional argument gives the initial value for the internal
     counter; it defaults to `1'.

`acquire([blocking])'
     Acquire a semaphore.

     When invoked without arguments: if the internal counter is larger
     than zero on entry, decrement it by one and return immediately.
     If it is zero on entry, block, waiting until some other thread has
     called `release()' to make it larger than zero.  This is done with
     proper interlocking so that if multiple `acquire()' calls are
     blocked, `release()' will wake exactly one of them up.  The
     implementation may pick one at random, so the order in which
     blocked threads are awakened should not be relied on.  There is no
     return value in this case.

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

     When invoked with BLOCKING 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 semaphore, incrementing the internal counter by one.
     When it was zero on entry and another thread is waiting for it to
     become larger than zero again, wake up that thread.