class Condition:
"""Class that implements a condition variable.
一个条件变量允许一个或多个线程等待,直到它们被另一个线程通知。
如果给出了锁的参数而不是None,它必须 self.acquire = lock.acquire
self.release = lock.release
# If the lock defines _release_save() and/or _acquire_restore(),
# these override the default implementations (which just call
# release() and acquire() on the lock). Ditto for _is_owned().
try:
self._release_save = lock._release_save
except AttributeError:
pass
try:
self._acquire_restore = lock._acquire_restore
except AttributeError:
pass
try:
self._is_owned = lock._is_owned
except AttributeError:
pass
# 多个线程等待的关键在这里,使用一个队列来记录等待的线程
# 实际是每次调用一个wait都会生成一把新的锁,放入到队列中
# 通过notify释放具体的锁,间接的实现唤醒的动作
# 如果需要唤醒多个线程,就是释放多把锁,也就间接唤醒了多个线程
self._waiters = _deque()
# 支持上下文操作
def __enter__(self):
return self._lock.__enter__()
# 支持上下文操作
def __exit__(self, *args):
return self._lock.__exit__(*args)
# 锁 + 当前有多少个线程在等待
def __repr__(self):
return "<Condition(%s, %d)>" % (self._lock, len(self._waiters))
# 释放操作
def _release_save(self):
self._lock.release() # No state to save
# 获取锁操作
def _acquire_restore(self, x):
self._lock.acquire() # Ignore saved state
# RLock 有自己的_is_owned
"""
def _is_owned(self):
return self._owner == get_ident()
"""
# 针对Lock的情况下,
# 可以使用下面的方式
def _is_owned(self):
# Return True if lock is owned by current_thread.
# This method is called only if _lock doesn't have _is_owned().
# 因为锁要么被持有,要没没有被持有
# 如果没有被持有,if 语句会立即进入,因此返回False
# 否则的话,返回True
if self._lock.acquire(0):
self._lock.release()
return False
else:
return True
def wait(self, timeout=None):
"""
等待,直到收到通知或发生超时为止。
如果调用此方法时,调用的线程还没有获得锁,就会产生一个RuntimeError。
该方法释放底层锁,然后阻塞,直到它被另一个线程的相同条件变量的notify()或notify_all()调用唤醒,或者直到可选的超时发生。一旦被唤醒或超时,它将重新获得锁并返回。
当超时参数存在而不是无时,它应该是一个浮点数,指定操作的超时,单位是秒(或其分数)。
当底层锁是一个RLock时,它不会使用其release()方法来释放,因为当它被多次递归获取时,这可能不会真正解锁。相反,RLock类的一个内部接口被使用,即使它被递归地获取了几次,也能真正解锁。然后,当锁被重新获取时,另一个内部接口被用来恢复递归级别。
"""
if not self._is_owned():
raise RuntimeError("cannot wait on un-acquired lock")
# 创建一把锁
waiter = _allocate_lock()
# 获取这把锁
waiter.acquire()
# 将这把锁加入到等待队列中
self._waiters.append(waiter)
saved_state = self._release_save()
gotit = False
try: # restore state no matter what (e.g., KeyboardInterrupt)
if timeout is None:
# block住,等待释放
waiter.acquire()
gotit = True
else:
if timeout > 0:
gotit = waiter.acquire(True, timeout)
else:
gotit = waiter.acquire(False)
return gotit
finally:
self._acquire_restore(saved_state)
if not gotit:
try:
self._waiters.remove(waiter)
except ValueError:
pass
def wait_for(self, predicate, timeout=None):
"""
等待,直到一个条件被评估为True。谓词应该是一个可调用的,
其结果将被解释为一个布尔值。
可以提供一个超时,给出最大的等待时间。
"""
endtime = None
waittime = timeout
result = predicate()
while not result:
if waittime is not None:
if endtime is None:
endtime = _time() + waittime
else:
waittime = endtime - _time()
if waittime <= 0:
break
self.wait(waittime)
result = predicate()
return result
def notify(self, n=1):
"""
唤醒一个或多个在此条件下等待的线程,如果有的话。
如果调用此方法时,调用的线程还没有获得锁,就会产生一个RuntimeError。
这个方法最多唤醒n个等待条件变量的线程;如果没有线程在等待,那么它就是一个无用功。
"""
if not self._is_owned():
raise RuntimeError("cannot notify on un-acquired lock")
all_waiters = self._waiters
waiters_to_notify = _deque(_islice(all_waiters, n))
if not waiters_to_notify:
return
for waiter in waiters_to_notify:
waiter.release()
try:
all_waiters.remove(waiter)
except ValueError:
pass
def notify_all(self):
"""
唤醒所有在此条件下等待的线程。
如果调用此方法时,调用的线程还没有获得锁,就会引发一个RuntimeError。
"""
self.notify(len(self._waiters))
notifyAll = notify_all