转载自本人知乎: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,否则就报错!
后面的就和父类一样了鸭~