转载自本人知乎：https://zhuanlan.zhihu.com/p/92702108
目录
1.with
2.condition
3.semaphore
1. with
还是有必要先讲解一下with的用法。它管理着类的“前世后生”，也就是在进入和退出类的时候调用。当然不是什么类都能够使用“with”：它必须实现两种“特殊方法”，即enter()和exit()；字面意思就可以看出来“入口”和“出口”。
基本用法：紧跟with后面的语句被求值后，返回对象的 enter() 方法被调用，这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被执行完之后，将调用前面返回对象的 exit()方法。
such as：
而在threading中，with常常和“锁”连用，常用方法如下：
with Lock as lock:
XXX
XXX
print(“END”)
# Just Like:
lock = Lock()
lock.acquire() # Notice!
XXX
XXX
print(“END”)
lock.release() # Notice!
我们在下面的源码中会经常看到。
2. condition
condition的本质也是一把“锁”，而且是个“递归锁”。最重要的是，它提供了wait()和notify()方法，而wait()方法就是利用“递归锁”，采用两级锁的方法实现了线程的等待。codition有两级锁，一把一级锁会在进入wait方法的时候释放，离开wait方法的时候再次获取，二级锁会在每次调用wait时分配一个新的锁，并放入condition的等待队列中，而notify负责释放这个锁。如下图：
源码（2-1/3）
class Condition:
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 releasesave() and/or acquirerestore(),
# these override the default implementations (which just call
# release() and acquire() on the lock). Ditto for isowned().
try:
self.releasesave = lock.releasesave
except AttributeError:
pass
try:
self.acquirerestore = lock.acquirerestore
except AttributeError:
pass
try:
self.isowned = lock.isowned
except AttributeError:
pass
self.waiters = deque()
def enter(self):
return self.lock.enter()
def exit(self, args):
return self.lock._exit(args)
def repr(self):
return “” % (self.lock, len(self.waiters))
def releasesave(self):
self.lock.release() # Nostate to save
def acquirerestore(self, x):
self.lock.acquire() #Ignore saved state
def isowned(self):
# Return True if lock is owned by current_thread.
# This method is called only if _lock doesn’t have _is_owned().
if self._lock.acquire(0):
self._lock.release()
return False
else:
return True
上述包括：__init__(), __enter__(), __exit__(), __repr__(), _release_save(), _acquire_restore(), _is_owned()；
(1).__enter__(), __exit__()：直接继承于Lock的上下文管理方式；
(2).__repr__()：特殊方法之一，好像是将condition类用str字符串的方法输出时候，调用此方法
(3)._is_owned()：如果一级锁由当前线程获得，返回True。它是怎么判断的呢？
他首先尝试获得一级锁，如果可以获得，那就说明当前线程没有锁，立马释放掉，返回false；反之，返回True；
(4)._release_save(), _acquire_restore()：
release_save = lock.release()，释放掉一级锁，保存状态
_acquire_restore = lock.acquire()，恢复一级锁
(5).__init__()：如果lock为none，则创建一个;
定义lock，即为一级锁；condition类继承locktype的acquire()和release()方法;这些都是非常有用的，且必须的！（废话吗这不是2333333）
如果lock类型定义了_release_save和_acquire_restore尝试重载他们;重载不掉就过，说明lock类型里面就有这种方式，则直接pass;
(6).定义 _waiters 双端队列，注意文件开头的：from collection import deque as _deque.
源码（2-2/3）
(1).wait()用于阻塞本线程，直到其他线程调用notify()唤醒或者timeout结束
Line2-3：线程想等待，自己要有锁吧；所以判断当前线程是否有锁，没有就抛出异常；
Line4-6：再定义一个lock方法，变量waiter，并获得这个二级锁（注意，RLock是递归锁，可以嵌套）；把这个锁添加进全局私有_waiter 集合最后
Line7：saved_state = self._release_save()，保存状态，释放一级锁；可以让其他线程获得，这样才能调用notify()；
Line8：定义一个bool类型的返回值gotit；
Line9-18：直接进入“try”
如果timeout == None，waiter上锁，线程就此阻塞，并且gotit = true ，等待有效；
否则判断timeout的正负性，如果正的，就获得锁线程就此阻塞，返回True赋值给gotit；反之返回False，等待失败；
Line19-25：try……finally……语句通常与资源回收有关
不管try是否含有return，不管try是否抛出异常，finally都会return之前执行。
注意到wait()有可能被用户和系统中断，导致没有上锁的waiter进入了_waiters队列：
finally中首先尝试恢复线程一级锁，也就是等待其他线程释放一级锁；没有就会一直等待。也就是说，调用notify函数的线程一定要释放掉底层锁，其他线程才会继续执行。
进一步判断gotit，如果为False，说明waiter没有释放，我们从_waiters中剔除它，注意他会和下面的notify()函数同时尝试，报错的话pass就行。
(2).wait_for()断言等待函数
Line27-29：定义了变量 endtime 结束时间和 waittime 等待时间，分别初始化为：None和传入的参数timeout。
result 获得断言的返回值，值得注意的是，断言的运行也是需要不少时间的，这个时间可能超过线程期望等待时间，下面就是要解决此问题。
Line30-40：断言为False则进入循环;
首先waittime，也就是timeout，不能是None；如果是None，那就没啥好说的，直接等待吧；如果不是才要继续判断。
在第一次进入循环的时候，计算出剩余的等待时间（扣除第一次等待断言返回的时间）。
这个时间太长就不能等待了；否则的话，等待剩余时间waittime，进而再计算断言；不管断言结果如何，都只能跳出循环了，因为waittime一定是<=0的。
3. semaphore
源码（3-1/3）
Semaphore，俗称信号量管理器，可以传入参数value，默认为1，当然他不等小于0；
首先实例化一个Semaphore类，判断value是否大于0，定义一个私有锁_Condition、和私有变量_value。
源码（3-2/3）
acquire(), release()：这个类中的acquier和release函数并不是传统意义上的获得锁和释放锁，他们在各自方法中分别获得、释放了一次锁。
维护了一个counter计数：它等于 = release()调用次数acquire()调用的数量 + 初始值。例如：当n个线程获得锁，acquire调用了n次，一次都没有调用release()的情况下，n不能大于value。
参数blocking：必要时可以阻止acquire()方法，直到线程返回并且计数器大于0。
注意acquire()函数过程判断传入参数，如果不能阻塞并且timeout还不为none，那肯定报错了。
定义rc返回值、定义endtime；endtime和timeout相互作用的方式，和wait_for()一样；
假设两个线程t1和t2。默认情况下，value = 1，t1获得私有锁，while循环不成立，value – 1，rc = True，释放私有锁；此时t2一直等待获得私有锁；但是t1释放私有锁之后，有两种可能：
（1）t2获得，并且value = 0
那么t2进入wait()等待，牛逼的是，进入wait后，会释放一级锁！
释放一级锁之后，t1中的release()就会获得；进一步调用notify函数唤醒t2！
（2）t1的release()获得
这种情况就相当于两个线程各玩各的，互不干扰，没有线程可以唤醒，notify（）直接pass就ok！
我画了个简图：
release()函数过程
value加一，调用notify，唤醒一个线程；
__enter__()和__exit__()魔法方法：使得类可以使用“with”上下文管理；其中__exit__()指向release()，还type,value,traceback三个参数，在with抛出异常的时候，分别表示异常的：类型，值和位置；不过也没利用起来
继承类BoundedSemaphore
源码（3-3/3）
继承于Semaphore。
实例化此类，首先创建一个Semaphore类，和一个私有变量_initial_value，表示初始化的_value值；
重载了Semaphore的release()方法；
而私有变量_initial_value的作用便在这里体现出来，就是release调用不能多于acquier，否则就报错！
后面的就和父类一样了鸭~