def notify(self, n=1): # notify()唤醒线程队列中前n个线程
"""Wake up one or more threads 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.
"""
# 和wait一样，必须在已获得Lock的前提下调用，否则将引发错误
if not self._is_owned(): # 自己获得一级锁
raise RuntimeError("cannot notify on un-acquired lock")
all_waiters = self._waiters # 备份当前线程队列
# islice(iterable, stop) --> islice object
waiters_to_notify = _deque(_islice(
all_waiters, n)) # 定义新得队列，将前n个线程转移至此，islice返回一个迭代器
if not waiters_to_notify: # 队列为空则返回，有可能被异常中断了
return
# 循环释放二级锁，wait函数中的wait.acquire()唤醒；最后尝试将线程踢出队列；和wait()两者共同尝试，
# 有一个成功了就行，要是抛出异常了就pass。
for waiter in waiters_to_notify:
waiter.release()
try:
all_waiters.remove(waiter)
except ValueError:
pass
def __init__(self, lock=None):
# 如果lock为none，则创建一个;
# 定义lock，即为一级锁
if lock is None: # threading.Condition()中没传递参数，默认lock=None
lock = RLock() # # 它的底层也是维护了一个RLock锁【底层锁】
self._lock = lock
# Export the lock's acquire() and release() methods
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().
# 如果lock类型定义了_release_save和_acquire_restore尝试重载他们;重载不掉就过，说明lock类型里面就有这种方式，直接pass;
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
# 双端队列存储所有等待中的锁
self._waiters = _deque(
) # _waiters 双端队列，注意文件开头的：from collection import deque as _deque.
def __init__(self, lock=None):
if lock is None:
lock = RLock()
self._lock = lock
# 导出lock的acquire（）和release（）方法
# Export the lock's acquire() and release() methods
self.acquire = lock.acquire
self.release = lock.release
# 如果锁定义_release_save（）和/或_acquire_restore（），
# If the lock defines _release_save() and/or _acquire_restore(),
# 这些覆盖了默认实现（只是在锁上调用release（）和acquire（））。 同上_is_owned（）。
# 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
self._waiters = _deque()
def __init__(self):
self._lock = RLock
self._waiters = _deque()
self._release_save = self._lock._release_save
self._acquire_restore = self._lock._acquire_restore
self._is_owned = self._lock._is_owned
def notify(self, n=1):
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(self, n=1):
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 __init__(self, lock=None):
if lock is None:
lock = RLock()
self._lock = lock
self.acquire = lock.acquire
self.release = lock.release
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
self._waiters = _deque()
def notify(self, n=1):
"""Wake up one or more threads 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.
"""
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(self, n=1):
"""Wake up one or more threads 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.
"""
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 __init__(self, lock=None):
if lock is None:
lock = RLock()
self._lock = lock
# Export the lock's acquire() and release() methods
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
self._waiters = _deque()
def __init__(self, lock=None):
if lock is None:
lock = RLock() # 默认RLock
self._lock = lock
# Export the lock's acquire() and release() methods
self.acquire = lock.acquire
self.release = lock.release # 本地化
# -----------------
# 若提供RLock的函数，本地化
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
# ----------------
self._waiters = _deque()
def __init__(self, lock=None):
if lock is None:
lock = RLock()
self._lock = lock
# Export the lock's acquire() and release() methods
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
self._waiters = _deque() # this is a queue for waiter thread ?
def clean(self):
self._lock.clean()
for waiters in _deque(_islice(self._waiters, len(self._waiters))):
waiters.clean()
