小猪的Python学习之旅 —— 11.Python并发之threading模块(2)

小猪的Python学习之旅 —— 11.Python并发之threading模块(2)

标签：Python

一句话概括本文：

本节继续把Python里threading线程模块剩下的Condition，Semaphore，

Event，Timer和Barrier讲解完毕，文档是枯燥无味的，希望通过简单

有趣的例子，可以帮你快速掌握这几个东东的用法～

啃文档是比较乏味的，先来个小姐姐提提神吧～




别问高清原图，程序猿自己动手，丰(营)衣(养)足(跟)食(不上)，

脚本自取：https://github.com/coder-pig/ReptileSomething

引言：

如果你忘记了threading上一部分内容，可以移步至：

小猪的Python学习之旅 —— 7.Python并发之threading模块(1)

温故知新，官方文档依旧是：

https://docs.python.org/3/library/threading.html

1.条件变量(Condition)

上节学习了Python为我们提供的第一个用于线程同步的东东——互斥锁，

又分Lock(指令锁)与RLock(可重入锁)，但是互斥锁只是最简单的同步机制，

Python为我们提供了Condition(条件变量)，以便于处理复杂线程同步问题，

比如最经典的生产者与消费者问题。

Condition除了提供与Lock类似的acquire()与release()函数外，还提供了

wait()与notify()函数。用法如下：

1.调用threading.Condition获得一个条件变量对象；

2.线程调用acquire获得Condition对象；

3.进行条件判断，不满足条件调用wait函数，满足条件，进行一些处理改变

条件后，调用notify函数通知处于wait状态的线程，重新进行条件判断。

写个简单的生产者与消费者例子体验下：

import threading
import time

condition = threading.Condition()
products = 0  # 商品数量

# 定义生产者线程类
class Producer(threading.Thread):
def run(self):
global products
while True:
if condition.acquire():
if products >= 99:
condition.wait()
else:
products += 2
print(self.name + "生产了2个产品，当前剩余产品数为：" + str(products))
condition.notify()
condition.release()
time.sleep(2)

# 定义消费者线程类
class Consumer(threading.Thread):
def run(self):
global products
while True:
if condition.acquire():
if products < 3:
condition.wait()
else:
products -= 3
print(self.name + "消耗了3个产品，当前剩余产品数为：" + str(products))
condition.notify()
condition.release()
time.sleep(2)

if __name__ == '__main__':
# 创建五个生产者线程
for i in range(5):
p = Producer()
p.start()
# 创建两个消费者线程
for j in range(2):
c = Consumer()
c.start()

运行结果：



Condition维护着一个互斥锁对象(默认是RLock)，也可以自己实例化一个

在Condition实例化的时候通过构造函数传入，SO，调用的Condition的

acquire与release函数，其实调用就是这个锁对象的acquire与release函数。

下面详解下除了acquire与release函数外Condition提供的相关函数吧：

(注：下述方法只有在acquire之后才能调用，不然会报RuntimeError异常)

wait(timeout=None)：释放锁，同时线程被挂起，直到收到通知被唤醒

或超时(如果设置了timeout)，当线程被唤醒并重新占有锁时，程序才继续执行；

wait_for(predicate, timeout=None)：等待知道条件为True，predicate应该是

一个回调函数，返回布尔值，timeout用于指定超时时间，返回值为回调函数

返回的布尔值，或者超时，返回False(3.2新增)；

notify(n=1)：默认唤醒一个正在的等待线程，notify并不释放锁！！！

notify_all()：唤醒所有等待线程，进入就绪状态，等待获得锁，notify_all 同样不释放锁！！！

2.信号量(Semaphore)

信号量，也是一个很容易懂的东西，举个简单的例子：

假如厕所里有五个蹲坑，有人来开大，就会占用一个坑位，

所剩余的坑位-1，当五个坑都被人占满的时候，新来的人

就只能在外面等，直到有人出来为止。

这里的五个粪坑就是信号量，蹲坑的人就是线程，

初始值为5，来人-1，走人+1；超过初始值，新来的处于堵塞状态；

原理很简单，试试看下源码：



看下_init_方法



传入参数value，默认值为1，不能传入负数，否则抛ValueError异常；

创建了一个Condition条件变量，传入一个Lock实例；

接着看下acquire函数：



先是判断，如果没有加锁然后设置了超时时间，抛出ValueError；

循环，如果value == 0，没有加锁或在超时时间内，跳出循环；

否则，调用Condition变量wait函数等待通知或超时；

如果value不为0，跳出循环执行else里的代码，信号量-1，rc = ture，

代表可以调用release函数，最后返回rc；

再接着是release函数，更简单



信号量+1，然后调用Condition变量的notify唤醒一个线程～

剩下的_enter_和_exit_就不用说了，重写这两个方法就能直接用with关键字了

就是那么简单，把我们蹲坑的那个例子写成代码吧：

import threading
import time
import random

s = threading.Semaphore(5)  # 粪坑

class Human(threading.Thread):
def run(self):
s.acquire()  # 占坑
print("拉屎拉屎 - " + self.name + " - " + str(time.ctime()))
time.sleep(random.randrange(1, 3))
print("拉完走人 - " + self.name + " - " + str(time.ctime()))
s.release()  # 走人

if __name__ == '__main__':
for i in range(10):
human = Human()
human.start()

输出结果：

3.通用的条件变量(Event)

Python提供的用于线程间通信的信号标志，一个线程标识了一个事件，

其他线程处于等待状态，直到事件发生后，所有线程都会被激活。

Event对象属性实现了简单的线程通信机制，提供了设置信号，清楚信号，

等待等用于实现线程间的通信。提供以下四个可供调用的方法：

is_set()：判断内部标志是否为真

set()：设置信号标志为真

clear()：清除Event对象内部的信号标志(设置为false)

wait(timeout=None)：使线程一直处于堵塞，知道标识符变为True

感觉有点蒙圈，看一波源码吧～



先是_init_函数



又是用到Condition条件变量，还有设置了一个_flag = False，这个就是标记吧！

is_set函数比较简单，返回_flag，



然后是set()函数：



加锁，然后设置_flag为true，然后notify_all唤醒所有线程，最后释放锁，

简单，接着clear函数呢？



注释的意思是：重置内部标记为false，随后，调用wait()的线程将被堵塞，

直到调用set()将内部标记再次设置为true。也很简单，最后是wait方法：



判断标志是否为False，False的话进入堵塞状态，(⊙v⊙)嗯

源码就那么简单，感觉看完还是蒙圈不知道怎么用，写个简单的例子？

汽车过红绿灯的例子：

import threading
import time
import random

class CarThread(threading.Thread):
def __init__(self, event):
threading.Thread.__init__(self)
self.threadEvent = event

def run(self):
# 休眠模拟汽车先后到达路口时间
time.sleep(random.randrange(1, 10))
print("汽车 - " + self.name + " - 到达路口...")
self.threadEvent.wait()
print("汽车 - " + self.name + " - 通过路口...")

if __name__ == '__main__':
light_event = threading.Event()

# 假设有20台车子
for i in range(20):
car = CarThread(event=light_event)
car.start()

while threading.active_count() > 1:
light_event.clear()
print("红灯等待...")
time.sleep(3)
print("绿灯通行...")
light_event.set()
time.sleep(2)

输出结果：

4.定时器(Timer)

与Thread类似，只是要等待一段时间后才会开始运行，单位秒，用法也很简单：

import threading
import time

def skill_ready():
print("!!!!!!大招已经准备好了!!!!!!")

if __name__ == '__main__':
t = threading.Timer(5, skill_ready)
t.start()
while threading.active_count() > 1:
print("======大招蓄力中======")
time.sleep(1)

输出结果：

5.栅栏(Barrier)

Barrier直译栅栏，感觉不是很好理解，网上有个形象化的例子，把他比喻

成赛马用的栅栏，然后马(线程)依次来到栅栏前等待(wait)，直到所有的马

都停在栅栏面前了，然后所有马开始同时出发(start)。

简单点说就是，多个线程间的相互等待，调用了wait()方法的线程进入堵塞，

直到所有的线程都调用了wait()方法，然后所有线程同时进行就绪状态，

等待调度运行。

构造函数：

Barrier(parties,action=None,timeout=None)

parties：创建一个可容纳parties条线程的栅栏；

action：全部线程被释放时可被其中一条线程调用的可调用对象；

timeout：线程调用wait()方法时没有显式设定timeout，就用的这个作为默认值；

相关函数：

wait(timeout=None)：表示线程就位，返回值是一个0到parties-1之间的整数，

每条线程都不一样，这个值可以用作挑选一条线程做些清扫工作，另外如果你在

构造函数里设置了action的话，其中一个线程在释放之前将会调用它。如果调用

出错的话，会让栅栏进入broken状态，超时同样也会进入broken状态，如果栅栏

在处于broke状态的时候调用reset函数，会抛出一个BrokenBarrierError异常。

reset()：本方法将栅栏置为初始状态，即empty状态。所有已经在等待的线程

都会接收到BrokenBarrierError异常，注意当有其他处于unknown状态的线程时，

调用此方法将可能获取到额外的访问。因此如果一个栅栏进入了broken状态，

最好是放弃他并新建一个栅栏，而不是调用reset方法。

abort()：将栅栏置为broken状态。本方法将使所有正在等待或将要调用

wait()方法的线程收到BrokenBarrierError异常。本方法的使用情景为，比如：

有一条线程需要abort()，又不想给其他线程造成死锁的状态，或许设定

timeout参数要比使用本方法更可靠。

parites：将要使用本 barrier 的线程的数量

n_waiting：正在等待本 barrier 的线程的数量

broken：栅栏是否为broken状态，返回一个布尔值

BrokenBarrierError：RuntimeError的子类，当栅栏被reset()或broken时引发；

(感觉都不知所云，写个简单的例子来熟悉下用法吧～)

例子：公司一起去旅游

import threading
import time
import random

class Staff(threading.Thread):
def __init__(self, barriers):
threading.Thread.__init__(self)
self.barriers = barriers

def run(self):
print("员工 【" + self.name + "】" + "出门")
time.sleep(random.randrange(1, 10))
print("员工 【" + self.name + "】" + "已签到")
self.barriers.wait()

def ready():
print(threading.current_thread().name + "：人齐，出发，出发～～～")

if __name__ == '__main__':
print("要出去旅游啦，大家快集合～")
b = threading.Barrier(10, action=ready, timeout=20)
for i in range(10):
staff = Staff(b)
staff.start()

运行结果：



PS：这里可以试下设置超时，还有修改ready方法，故意引起异常，

然后会抛出BrokenBarrierError异常。

6.小结

加了下班，终于把threading模块啃完了，不然爬小姐姐好玩，有成就感，

当然Python线程肯定不止那么简单，后面还有队列这些东西～慢慢来，不急。

下一节开始抠multiprocessing这个进程模块，又是块大骨头，敬请期待～

本节参考文献：

官方文档

Python多线程之Threading.Event

Python的多线程编程模块 threading 参考

来啊，Py交易啊

欢迎各种像我一样的Py初学者，或者Py大神加入，

一起愉快地交流学♂习：



因为微信群二维码隔一段时间就过期了，如果二维码过期可加我，

我拉你进群，懒得换二维码了~(加我记得写明加群，不然一律不加！)