Python中的threading

RLock——重入锁

RLock在Python中的实现是对Lock的封装，具体在类中维护了一个重入次数的变量。一旦一个线程获得一个RLock，该线程再次要求获得该锁时不会阻塞，但该线程获得多少次该锁，则必须释放多少次。一个重入锁必须由获得该锁的线程释放。

源码实现：

数据结构：

__block：普通Lock
__owner：该锁的拥有者线程
__count：该锁被拥有者线程重入的次数

具体方法：

acquire(self, blocking=1)：获取锁

def acquire(self, blocking=1):
    me = _get_ident()				# 得到调用该函数线程的ID
    if self.__owner == me:		# 与self.__owner对比
        self.__count = self.__count + 1	# 相等，则说明之前该锁就属于该线程，则重入次数自增
        return 1	# 返回获取成功
    rc = self.__block.acquire(blocking)	# 不等的话，则尝试获取__block锁
    if rc:	# 如果获取成功
        self.__owner = me		# 则将该锁的拥有者赋值为该线程
        self.__count = 1		# 并将重入次数自增
    return rc					# 返回获取成功与否

release(self)：释放锁

def release(self):
    if self.__owner != _get_ident():	# 如果当前该锁的拥有者线程不是调用该函数的线程，抛出异常
        raise RuntimeError("cannot release un-acquired lock")
    self.__count = count = self.__count - 1 # 否则，重入次数自减
    if not count:					# 当重入次数为0时
        self.__owner = None		# 该锁拥有者为None
        self.__block.release()	# 且释放__block

Condition——条件变量

Condition对象允许一个或多个线程等待直到它们被其它线程通知，然后继续执行。Condition除了提供与Lock类似的acquire和release方法外，还提供了wait和notify方法。可以将Condition看成一个有条件的锁，其中增加了当不满足条件时，需等待的接口。

一个线程首先调用condition的acquire方法，然后判断一些条件，如不满足则wait；如果条件满足，进行一些处理，通过notify方法来通知其他线程。

源码实现：

数据结构：

__lock：Lock或者RLock实例，Condition中锁的实现
__waiters：等待的线程

具体方法：

wait(self, timeout=None)：条件不满足时等待

def wait(self, timeout=None):
    if not self._is_owned():		# 调用该函数前，必须先获取锁
        raise RuntimeError("cannot wait on un-acquired lock")
    waiter = _allocate_lock()		# 申请一个普通的Lock
    waiter.acquire()				# 首先先获取了，再获取需阻塞
    self.__waiters.append(waiter)	# 即将该线程挂到锁上面，再把锁弄进等待队列
    saved_state = self._release_save()	# 释放锁，保存锁的一些状态，当为重入锁时，则需保存锁的拥有者和重入次数状态
    try:    # restore state no matter what (e.g., KeyboardInterrupt)
        if timeout is None:		# 当timeout为空，则代表永久阻塞
            waiter.acquire()		# 再获取，即该线程会阻塞到该锁上
        else:
            # Balancing act:  We can't afford a pure busy loop, so we
            # have to sleep; but if we sleep the whole timeout time,
            # we'll be unresponsive.  The scheme here sleeps very
            # little at first, longer as time goes on, but never longer
            # than 20 times per second (or the timeout time remaining).
            endtime = _time() + timeout
            delay = 0.0005 # 500 us -> initial delay of 1 ms
            while True:
                gotit = waiter.acquire(0)
                if gotit:		如果在规定时间内有其他线程通知了该线程，则退出
                    break
                remaining = endtime - _time()
                if remaining <= 0:		# 如果超时，则退出
                    break
                delay = min(delay * 2, remaining, .05)	# 获取需要的睡眠时间，每次延长
                _sleep(delay)
            if not gotit:
                try:
                    self.__waiters.remove(waiter)
                except ValueError:
                    pass
    finally:
        self._acquire_restore(saved_state)	# 最后竞争该锁，恢复状态

notify(self, n=1)：唤醒n个线程

def notify(self, n=1):
    if not self._is_owned():		# 必须拥有锁的状态下，才能调用notify
        raise RuntimeError("cannot notify on un-acquired lock")
    __waiters = self.__waiters
    waiters = __waiters[:n]	# 唤醒前n个
    if not waiters:
        return
    for waiter in waiters:
        waiter.release()		# 唤醒
        try:
            __waiters.remove(waiter)	# 从等待的队列中移除
        except ValueError:
            pass

notifyAll(self)：唤醒所有在该condition上等待的线程

def notifyAll(self):
    self.notify(len(self.__waiters))

Semaphore——信号量

Semaphore维护了一个计数器，代表release调用的次数 - acquire调用次数 + 计数器初始值。最简单的应用为操作系统中，某个资源（例如打印机）的个数为n，线程的数量为m，当线程抢占资源时，可以使用Semaphore来保证资源利用的合理性。

源码实现：

数据结构：

__cond：为Condition(Lock())，当资源数不够时，调用__cond的wait()方法来等待其他线程释放资源的通知(notify())
__value：为int型，代表初始资源的个数

具体方法：

acqiure(self, blocking=1)：抢占其中一个资源

def acquire(self, blocking=1):
    rc = False
    with self.__cond:		# 首先抢占条件变量的锁，以下代码为多个线程互斥访问
        while self.__value == 0:
            if not blocking:
                break
            self.__cond.wait()	# 当资源为0时， 则等待别的线程释放，唤醒则继续判断资源个数
        else:
            self.__value = self.__value - 1	# 否则资源足够，则减一，表示获取一个资源
            rc = True
    return rc

release(self)：释放一个资源

def release(self):
    with self.__cond:		# 同样，先抢占条件变量锁，以下代码互斥访问
        self.__value = self.__value + 1	# 资源数加一，表示该线程用好资源了
        self.__cond.notify()	# 唤醒其中一个线程叫它来抢资源

Event——事件监听

Event机制类似于事件的监听机制，其他线程调用wait()方法阻塞监听一个事件的发生，当某个线程检测到事件的发生，会向所有等待的线程发送一个信号，等待线程重新唤醒继续执行。

源码实现

数据结构

__cond：为Condition(Lock())，当事件未发生时，调用__cond的wait()方法阻塞等待事件发生
__flag：初始值为false，代表事件未发生，当发生时，置为true

具体方法

wait(self, timeout=None)：等待直到`__flag`为true

def wait(self, timeout=None):
    self.__cond.acquire()		# 抢占条件变量的锁
    try:
        if not self.__flag:	# 查看事件发生与否
            self.__cond.wait(timeout)	# 如未发生，则阻塞
        return self.__flag
    finally:
        self.__cond.release()

set(self)：设置`__flag`为true，表明事件的发生

def set(self):
    self.__cond.acquire()		# 抢占条件变量的锁
    try:
        self.__flag = True	# 设置事件发生
        self.__cond.notify_all()		# 通知所有等待的线程
    finally:
        self.__cond.release()