gevent.lock
– Locking primitives¶Semaphore
(value=1) → Semaphore[source]¶Bases: object
A semaphore manages a counter representing the number of release() calls minus the number of acquire() calls, plus an initial value. The acquire() method blocks if necessary until it can return without making the counter negative.
If not given, value
defaults to 1.
The semaphore is a context manager and can be used in with
statements.
This Semaphore’s __exit__
method does not call the trace function
on CPython, but does under PyPy.
See also
BoundedSemaphore
for a safer version that prevents
some classes of bugs.
acquire
(blocking=True, timeout=None) → bool[source]¶Acquire the semaphore.
Caution
If this semaphore was initialized with a size of 0, this method will block forever (unless a timeout is given or blocking is set to false).
Parameters: |
|
---|---|
Returns: | A boolean indicating whether the semaphore was acquired.
If |
locked
()[source]¶Return a boolean indicating whether the semaphore can be acquired. Most useful with binary semaphores.
rawlink
(callback) → None[source]¶Register a callback to call when a counter is more than zero.
callback will be called in the Hub
, so it must not use blocking gevent API.
callback will be passed one argument: this instance.
This method is normally called automatically by acquire()
and wait()
; most code
will not need to use it.
unlink
(callback) → None[source]¶Remove the callback set by rawlink()
.
This method is normally called automatically by acquire()
and wait()
; most
code will not need to use it.
wait
(timeout=None) → int[source]¶Wait until it is possible to acquire this semaphore, or until the optional timeout elapses.
Caution
If this semaphore was initialized with a size of 0, this method will block forever if no timeout is given.
Parameters: | timeout (float) – If given, specifies the maximum amount of seconds this method will block. |
---|---|
Returns: | A number indicating how many times the semaphore can be acquired before blocking. |
DummySemaphore
(value=None) → DummySemaphore[source]¶Bases: object
A Semaphore initialized with “infinite” initial value. None of its methods ever block.
This can be used to parameterize on whether or not to actually
guard access to a potentially limited resource. If the resource is
actually limited, such as a fixed-size thread pool, use a real
Semaphore
, but if the resource is unbounded, use an
instance of this class. In that way none of the supporting code
needs to change.
Similarly, it can be used to parameterize on whether or not to
enforce mutual exclusion to some underlying object. If the
underlying object is known to be thread-safe itself mutual
exclusion is not needed and a DummySemaphore
can be used, but
if that’s not true, use a real Semaphore
.
Changed in version 1.1rc3: Accept and ignore a value argument for compatibility with Semaphore.
BoundedSemaphore
(value=1) → BoundedSemaphore[source]¶Bases: gevent._semaphore.Semaphore
A bounded semaphore checks to make sure its current value doesn’t
exceed its initial value. If it does, ValueError
is
raised. In most situations semaphores are used to guard resources
with limited capacity. If the semaphore is released too many times
it’s a sign of a bug.
If not given, value defaults to 1.
Next page: The Event Loop and the Hub