Python生產者與消費者模型中的優勢介紹

from  multiprocessing import Process,Queue  #多行程群元件,佇列
import time,random  
#生產者方法
def producer(name,food,q):
    for i in  range(4):
        time.sleep(random.randint(1,3)) #模擬獲取資料時間
        f = '%s生產的%s%s'%(name,food,i)
        print(f)
        q.put(f) #新增進佇列
#消費者方法
def consumer(q,name):
    while True:
        food = q.get() #如果獲取不到，會一直阻塞程序不會結束子程序
        # 當佇列中的資料是None的時候結束while迴圈
        if food is None:
            print('%s獲取到一個空'%name)
            break
        f = '33[31m%s消費了%s33[0m' % (name, food)
        print(f)
        time.sleep(random.randint(1,3)) # 模擬消耗資料時間
if __name__ == '__main__':
    q = Queue()  # 建立佇列
    # 模擬生產者 生產資料
    p = Process(target=producer, args=('p', '包子', q)) #建立程序
    p.start() #啟動程序
    p1 = Process(target=producer, args=('p1', '燒餅', q))
    p1.start()
   #模擬消費者消費資料
    c = Process(target=consumer, args=(q, 'c'))
    c.start()
    c1 = Process(target=consumer, args=(q, 'c1'))
    c1.start()
    p.join()#阻塞主程序 直到p和p1 子程序結束後才執行q.put() 方法
    p1.join()#阻塞主程序 直到p和p1 子程序結束後才執行q.put() 方法
    #為了確保生產者生產完所有資料後，
    #最後一個是None,方便結束子程序中的while迴圈,
    #否則會一直等待佇列中加入新資料。
    q.put(None)
    q.put(None)

from multiprocessing import JoinableQueue,Process
import time,random
#生產者方法
def producer(name,food,q):
    for i in range(4):
        time.sleep(random.randint(1, 2))
        f = '%s生產的%s%s'%(name,food,i)
        q.put(f)
        print(f)
    q.join()  #一直阻塞，等待消耗完所有的資料後才釋放
#消費者方法
def consumer(name,q):
    while True:
        food = q.get()
        print('33[31m%s消費了%s33[0m' % (name, food))
        time.sleep(random.randint(4,8))
        q.task_done() #每次消耗減1
if __name__ == '__main__':
    q = JoinableQueue()  #建立佇列
    #模擬生產者佇列
    p1 = Process(target=producer,args=('p1','包子',q))
    p1.start()
    p2 = Process(target=producer,args=('p2','燒餅',q))
    p2.start()
    #模擬消費者佇列
    c1 = Process(target=consumer,args=('c1',q))
    c1.daemon = True #守護行程：主程序結束，子程序也會結束
    c1.start()
    c2 = Process(target=consumer,args=('c2',q))
    c2.daemon = True
    c2.start()
    p1.join() #阻塞主程序，等到p1子程序結束才往下執行
    p2.join()
    # q.task_done() 每次消耗佇列中的 任務數減1
    # q.join() 一直阻塞，等待佇列中的任務數消耗完才釋放
    # 因為有 q.join 所有一直會等待 c1,c2 消耗完畢。才會執行 p.join 後面的程式碼
    # 因為 c1 c2 是守護行程，所以到這一步主程序程式碼執行完畢，主程序會釋放死掉，
    # 所以 c1 c2 也會跟隨 主程序釋放死掉。