事件（events）
基于event实现绿灯举例的多线程 程序
import time
import threading
event = threading.Event()
def lighter():
count = 0
event.set()
##先设置标志位为真，表示初始状态就是绿灯。否则当下面的if count > 5之前，标志位都是没有被设置的
while True:
if count > 5 and count <10: #大于5并且小于10就改成红灯
# 这里代码不能只写成if count > 5，因为只要满足大于5，就不会去匹配大于10的elif条件了。
event.clear() #把标志位清空，检查标志位，如果标志位没有被设置，则当做红灯。
print ("\033[41;1m red light is on...\033[0m")
## 这里>5 and <10的数是6-9，所以这里会打印红灯4次。
elif count > 10: #红灯到绿灯期间设置时间为10秒，当大于30时，设置标志位
event.set() #设置标志位，检查到这个标志位，就当做已经绿灯
count = 0 #用count来计数多少秒，当设置为绿灯时就清空为0秒，20秒后就红灯
else:
print("\033[42;1m green light is on...\033[0m")
## 匹配count既不大于5，也不大于10时（也就是小于5时），打印绿灯亮
## 这里0-5会打印绿灯6次。
time.sleep(1) #设置每一秒循环一次，这样20秒后就红灯，20秒到30秒后就变成绿灯。
count += 1
def car(name):
while True:
if event.is_set(): #这里判断如果事件设置了标志位（表示绿灯）
print ("[%s] running..." %name)
time.sleep(1)
else: #标志位为空表示红灯
print ("[%s] sees red light, waiting......" %name)
event.wait() #如果判断标志位为空，则阻塞程序，直到标志位为真。
print ("[%s] green light is on, start going... "%name)
light = threading.Thread(target=lighter,)
light.start()
car1 = threading.Thread(target=car,args=("car1",))
car1.start()
执行结果：
可以看到绿灯时，车就正常行驶； 红灯时就等待。
队列（queue）
FIFO（先进先出）
队列的作用：
1、解耦：避免两者之间的过度依赖，以免其中一方出现问题，另一方不能再执行。
2、效率：增加数据处理的效率。
队列可以理解为一个容器，用来放数据的，不过这个容器中的数据是有顺序的。
import queue
q = queue.Queue() #先生成一个队列对象
q.put("d1") #将d1这个数据放入队列中
q.put("d2") #将d2这个数据也放入队列中
q.put("d3")
q.qsize() # 来查询当前队列数据数量
print (q.get()) #这里不能取出指定的数据，只能根据先进先出的顺序来取出数据，所以这里取出的是"d1"这个数据
print (q.get()) #这里取出的是"d2"这个数据
print (q.get()) #这里取出的是"d3"这个数据
执行结果：
d1
d2
d3
## 先进先出的顺序来get数据
10办公
import queue
q = queue.Queue()
q.put("d1")
q.put("d2")
q.put("d3")
q.qsize()
print (q.get())
print (q.get())
print (q.get())
print (q.get())
## 之前只进入了3个数据，且3个数据也被取出了，此时数据为空，我再次取数据就会卡在这，因为没有数据了，会一直卡在这等待新的数据进来
执行结果：
可以看到程序卡主了。
import queue
q = queue.Queue()
q.put("d1")
q.put("d2")
q.put("d3")
q.qsize()
print (q.get())
print (q.get())
print (q.get())
print (q.get(block=False))
## 默认就存在block=True这个参数，True的话表示如果数据为空就卡主，设置False就不卡主
不在卡主，并且抛出异常
import queue
q = queue.Queue()
q.put("d1")
q.put("d2")
q.put("d3")
q.qsize()
print (q.get())
print (q.get())
print (q.get())
print (q.get(timeout=3))
## 设置如果卡主的话，卡多久，这里设置为卡3秒
卡3秒后，依然没有数据进来，会抛出异常。
import queue
q = queue.Queue()
q.put("d1")
q.put("d2")
q.put("d3")
q.qsize()
print (q.get())
print (q.get())
print (q.get())
print (q.get_nowait())
## 使用get_nowait()来取数据，如果取的数据是空就会抛出异常。
可以使用try,except异常来使用get_nowait()来解决获取空数据的问题；
也可以使用if q.qsize()来判断==0的话，就是空数据，然后在做下一步操作。
import queue
q = queue.Queue(maxsize=3) ## 设置队列中最多可以有多少个数据
q.put("d1")
q.put("d2")
q.put("d3")
q.put("d4") ##因为设置最有能有3个数据，当我们设置第4个数据的时候前三个数据还没有取出，就会卡主
##可以设置多个线程，边放边取数据，就不会卡主了。
import queue
q = queue.Queue(maxsize=3)
q.put("d1")
q.put("d2")
q.put("d3")
q.put("d4",block=False,timeout=3)
## put也支持block和timeout
Lifo （last in first out 后进先出）
一般场景都是先入先出，后入先出的情况比较少。
卖水果就可以实现后入先出的场景，因为后来的水果比较新鲜，所以就先卖出去的快。
import queue
q = queue.LifoQueue()
q.put(1)
q.put(2)
q.put(3)
print (q.get())
print (q.get())
print (q.get())
执行结果：
3
2
1
PriorityQueue（优先级队列）
存储数据时可以设置优先级队列
import queue
q = queue.PriorityQueue()
q.put((10,"Amy"))
q.put((-1,"Peter"))
q.put((3,"Zhangsan"))
q.put((6,"lisi"))
print (q.get())
print (q.get())
print (q.get())
print (q.get())
执行结果：
(-1, 'Peter') #优先级最高
(3, 'Zhangsan')
(6, 'lisi')
(10, 'Amy') #优先级最低
##将数字放在前面就按照数字越小，越优先出
## 也可以按照字母等顺序来排列。
生产者消费者模型
假如生产者是视频服务器，消费者是用户，用户消费（看视频），将请求转到后台服务器，生产者处理、提供视频数据。
但是消费者并不关心你后台提供了多少台服务器，所以这种模型解耦比较好。
import threading,time
import queue
q = queue.Queue()
def Producer(name):
for i in range(10):
q.put("骨头%s"%i) ##生产10个骨头
def Consumer(name):
while q.qsize() > 0: #判断队列还有数据就循环
print ("[%s]取到[%s]并且吃了它..."%(name,q.get())) #消费骨头
p = threading.Thread(target=Producer,args=("LiSi",))
c = threading.Thread(target=Consumer,args=("Dog",))
p.start()
c.start()
执行结果：
[Dog]取到[骨头0]并且吃了它...
[Dog]取到[骨头1]并且吃了它...
[Dog]取到[骨头2]并且吃了它...
[Dog]取到[骨头3]并且吃了它...
[Dog]取到[骨头4]并且吃了它...
[Dog]取到[骨头5]并且吃了它...
[Dog]取到[骨头6]并且吃了它...
[Dog]取到[骨头7]并且吃了它...
[Dog]取到[骨头8]并且吃了它...
[Dog]取到[骨头9]并且吃了它...
## 生产了10个骨头，都被dog给吃了。
import threading,time
import queue
q = queue.Queue(maxsize=10) #最大放入十个骨头
def Producer(name):
count = 1
while True: #为了持续性的生产骨头，这里使用while。
q.put("骨头%s"%count) ##当骨头超过10个的时候，就卡主了，直到骨头被取出少于10时循环放骨头进来
print ("生产了骨头%s"%count)
count += 1
time.sleep(2) #两秒生产1个
def Consumer(name):
while True: #这里设置True，而不是>0，因为刚生产1个被吃掉的话，就不大于0了，dogs就不会再吃骨头
print ("[%s]取到[%s]并且吃了它..."%(name,q.get()))
time.sleep(1) #这里设置每秒吃1个骨头但是因为生产的慢（2秒生产1个），所以就吃的慢。
p = threading.Thread(target=Producer,args=("LiSi",))
c1 = threading.Thread(target=Consumer,args=("Dog1",))
c2 = threading.Thread(target=Consumer,args=("Dog2",))
p.start()
c1.start()
c2.start()
执行结果：
生产了骨头1
[Dog1]取到[骨头1]并且吃了它...
生产了骨头2
[Dog2]取到[骨头2]并且吃了它...
生产了骨头3
[Dog1]取到[骨头3]并且吃了它...
生产了骨头4
[Dog2]取到[骨头4]并且吃了它...
生产了骨头5
[Dog1]取到[骨头5]并且吃了它...
生产了骨头6
[Dog2]取到[骨头6]并且吃了它...
........
def Producer(name):
count = 1
while True:
q.put("骨头%s"%count)
print ("生产了骨头%s"%count)
count += 1
time.sleep(0.5) #现在0.5秒生产1个，相当于1秒生产2个
def Consumer(name):
while True:
print ("[%s]取到[%s]并且吃了它..."%(name,q.get()))
time.sleep(1)
##因为生产的快，两个线程就吃的快（每个线程每隔1秒吃一个）
##两个线程相当于1秒能吃2个，刚好与生产速度持平；
##如果生产过快的话，就是生产大于消费的速度了。
p = threading.Thread(target=Producer,args=("LiSi",))
c1 = threading.Thread(target=Consumer,args=("Dog1",))
c2 = threading.Thread(target=Consumer,args=("Dog2",))
p.start()
c1.start()
c2.start()
执行结果：
生产了骨头1
[Dog1]取到[骨头1]并且吃了它...
生产了骨头2
[Dog2]取到[骨头2]并且吃了它...
生产了骨头3
[Dog1]取到[骨头3]并且吃了它...
生产了骨头4
[Dog2]取到[骨头4]并且吃了它...
生产了骨头5
[Dog1]取到[骨头5]并且吃了它...
## 生产者消费者模型解决了解耦（生产和消费各干各的）、排队的问题（只要生产的资源够，消费者不需要排队）。
