事件（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]並且吃了它...
## 生產者消費者模型解決了解耦（生產和消費各幹各的）、排隊的問題（只要生產的資源夠，消費者不需要排隊）。