class threading.Condition(lock=None)
This class implements condition variable objects. A condition variable allows one or more threads to wait until they are notified by another thread.
If the lock argument is given and not None
, it must be a Lock
or RLock
object, and it is used as the underlying lock. Otherwise, a new RLock
object is created and used as the underlying lock.
Changed in version 3.3: changed from a factory function to a class.
-
acquire(*args)
-
Acquire the underlying lock. This method calls the corresponding method on the underlying lock; the return value is whatever that method returns.
-
release()
-
Release the underlying lock. This method calls the corresponding method on the underlying lock; there is no return value.
-
wait(timeout=None)
-
Wait until notified or until a timeout occurs. If the calling thread has not acquired the lock when this method is called, a
RuntimeError
is raised.This method releases the underlying lock, and then blocks until it is awakened by a
notify()
ornotify_all()
call for the same condition variable in another thread, or until the optional timeout occurs. Once awakened or timed out, it re-acquires the lock and returns.When the timeout argument is present and not
None
, it should be a floating point number specifying a timeout for the operation in seconds (or fractions thereof).When the underlying lock is an
RLock
, it is not released using itsrelease()
method, since this may not actually unlock the lock when it was acquired multiple times recursively. Instead, an internal interface of theRLock
class is used, which really unlocks it even when it has been recursively acquired several times. Another internal interface is then used to restore the recursion level when the lock is reacquired.The return value is
True
unless a given timeout expired, in which case it isFalse
.Changed in version 3.2: Previously, the method always returned
None
.
-
wait_for(predicate, timeout=None)
-
Wait until a condition evaluates to True. predicate should be a callable which result will be interpreted as a boolean value. A timeout may be provided giving the maximum time to wait.
This utility method may call
wait()
repeatedly until the predicate is satisfied, or until a timeout occurs. The return value is the last return value of the predicate and will evaluate toFalse
if the method timed out.Ignoring the timeout feature, calling this method is roughly equivalent to writing:
while not predicate(): cv.wait()
Therefore, the same rules apply as with
wait()
: The lock must be held when called and is re-acquired on return. The predicate is evaluated with the lock held.New in version 3.2.
-
notify(n=1)
-
By default, wake up one thread waiting on this condition, if any. If the calling thread has not acquired the lock when this method is called, a
RuntimeError
is raised.This method wakes up at most n of the threads waiting for the condition variable; it is a no-op if no threads are waiting.
The current implementation wakes up exactly n threads, if at least n threads are waiting. However, it’s not safe to rely on this behavior. A future, optimized implementation may occasionally wake up more than n threads.
Note: an awakened thread does not actually return from its
wait()
call until it can reacquire the lock. Sincenotify()
does not release the lock, its caller should.
-
notify_all()
-
Wake up all threads waiting on this condition. This method acts like
notify()
, but wakes up all waiting threads instead of one. If the calling thread has not acquired the lock when this method is called, aRuntimeError
is raised.
Please login to continue.