2.Python程式間的通訊之佇列（Queue）和生產者消費者模型

lzl_121發表於2021-04-23
Python佇列模型

一、佇列

1.1 概念介紹-----multiprocess.Queue

建立共享的程式佇列，Queue是多程式安全的佇列，可以使用Queue實現多程式之間的資料傳遞。

Queue([maxsize])建立共享的程式佇列。
引數 ：maxsize是佇列中允許的最大項數。如果省略此引數，則無大小限制。

底層佇列使用管道和鎖定實現。

1.2 方法介紹

Queue([maxsize])：建立共享的程式佇列。maxsize是佇列中允許的最大項數。如果省略此引數，則無大小限制。底層佇列使用管道和鎖定實現。另外，還需要執行支援執行緒以便佇列中的資料傳輸到底層管道中。
Queue的例項q具有以下方法：

q.get( [ block [ ,timeout ] ] )：返回q中的一個專案。如果q為空，此方法將阻塞，直到佇列中有專案可用為止。block用於控制阻塞行為，預設為True. 如果設定為False，將引發Queue.Empty異常（定義在Queue模組中）。timeout是可選超時時間，用在阻塞模式中。如果在制定的時間間隔內沒有專案變為可用，將引發Queue.Empty異常。

q.get_nowait() ：同q.get(False)方法。

q.put(item [, block [,timeout ] ] ) ：將item放入佇列。如果佇列已滿，此方法將阻塞至有空間可用為止。block控制阻塞行為，預設為True。如果設定為False，將引發Queue.Empty異常（定義在Queue庫模組中）。timeout指定在阻塞模式中等待可用空間的時間長短。超時後將引發Queue.Full異常。

q.qsize() ：返回佇列中目前專案的正確數量。此函式的結果並不可靠，因為在返回結果和在稍後程式中使用結果之間，佇列中可能新增或刪除了專案。在某些系統上，此方法可能引發NotImplementedError異常。

q.empty() ：如果呼叫此方法時 q為空，返回True。如果其他程式或執行緒正在往佇列中新增專案，結果是不可靠的。也就是說，在返回和使用結果之間，佇列中可能已經加入新的專案。

q.full() ：如果q已滿，返回為True. 由於執行緒的存在，結果也可能是不可靠的（參考q.empty()方法）。

1.3 其他方法(瞭解)

q.close() ：關閉佇列，防止佇列中加入更多資料。呼叫此方法時，後臺執行緒將繼續寫入那些已入佇列但尚未寫入的資料，但將在此方法完成時馬上關閉。如果q被垃圾收集，將自動呼叫此方法。關閉佇列不會在佇列使用者中生成任何型別的資料結束訊號或異常。例如，如果某個使用者正被阻塞在get()操作上，關閉生產者中的佇列不會導致get()方法返回錯誤。

q.cancel_join_thread() ：不會再程式退出時自動連線後臺執行緒。這可以防止join_thread()方法阻塞。

q.join_thread() ：連線佇列的後臺執行緒。此方法用於在呼叫q.close()方法後，等待所有佇列項被消耗。預設情況下，此方法由不是q的原始建立者的所有程式呼叫。呼叫q.cancel_join_thread()方法可以禁止這種行為。

1.4 程式碼例項 ---multiprocess.Queue

1.4.1佇列用法

'''
multiprocessing模組支援程式間通訊的兩種主要形式:管道和佇列
都是基於訊息傳遞實現的,但是佇列介面
'''

from multiprocessing import Queue
q=Queue(3)

#put ,get ,put_nowait,get_nowait,full,empty
q.put(3)
q.put(3)
q.put(3)
# q.put(3)   # 如果佇列已經滿了，程式就會停在這裡，等待資料被別人取走，再將資料放入佇列。
           # 如果佇列中的資料一直不被取走，程式就會永遠停在這裡。
try:
    q.put_nowait(3) # 可以使用put_nowait，如果佇列滿了不會阻塞，但是會因為佇列滿了而報錯。
except: # 因此我們可以用一個try語句來處理這個錯誤。這樣程式不會一直阻塞下去，但是會丟掉這個訊息。
    print('佇列已經滿了')

# 因此，我們再放入資料之前，可以先看一下佇列的狀態，如果已經滿了，就不繼續put了。
print(q.full()) #滿了

print(q.get())
print(q.get())
print(q.get())
# print(q.get()) # 同put方法一樣，如果佇列已經空了，那麼繼續取就會出現阻塞。
try:
    q.get_nowait(3) # 可以使用get_nowait，如果佇列滿了不會阻塞，但是會因為沒取到值而報錯。
except: # 因此我們可以用一個try語句來處理這個錯誤。這樣程式不會一直阻塞下去。
    print('佇列已經空了')

print(q.empty()) #空了

上面這個例子還沒有加入程式通訊，只是先來看看佇列為我們提供的方法，以及這些方法的使用和現象。

1.4.2 子程式傳送資料給父程式

import time
from multiprocessing import Process, Queue

def f(q):
    q.put([time.asctime(), 'from Eva', 'hello'])  #呼叫主函式中p程式傳遞過來的程式引數 put函式為向佇列中新增一條資料。

if __name__ == '__main__':
    q = Queue() #建立一個Queue物件
    p = Process(target=f, args=(q,)) #建立一個程式
    p.start()
    print(q.get())
    p.join()

上面是一個queue的簡單應用，使用佇列q物件呼叫get函式來取得佇列中最先進入的資料。 接下來看一個稍微複雜一些的例子：批量生產資料放入佇列再批量獲取結果。

1.4.3 批量生產資料放入佇列再批量獲取結果

import os
import time
import multiprocessing

# 向queue中輸入資料的函式
def inputQ(queue):
    info = str(os.getpid()) + '(put):' + str(time.asctime())
    queue.put(info)

# 向queue中輸出資料的函式
def outputQ(queue):
    info = queue.get()
    print ('%s%s%s'%(str(os.getpid()), '(get):',info))

# Main
if __name__ == '__main__':
    multiprocessing.freeze_support()
    record1 = []   # store input processes
    record2 = []   # store output processes
    queue = multiprocessing.Queue(3)

    # 輸入程式
    for i in range(10):
        process = multiprocessing.Process(target=inputQ,args=(queue,))
        process.start()
        record1.append(process)

    # 輸出程式
    for i in range(10):
        process = multiprocessing.Process(target=outputQ,args=(queue,))
        process.start()
        record2.append(process)

    for p in record1:
        p.join()

    for p in record2:
        p.join()

二、生產者消費者模型

在併發程式設計中使用生產者和消費者模式能夠解決絕大多數併發問題。該模式通過平衡生產執行緒和消費執行緒的工作能力來提高程式的整體處理資料的速度。

2.1 為什麼要使用生產者和消費者模式

線上程世界裡，生產者就是生產資料的執行緒，消費者就是消費資料的執行緒。在多執行緒開發當中，如果生產者處理速度很快，而消費者處理速度很慢，那麼生產者就必須等待消費者處理完，才能繼續生產資料。同樣的道理，如果消費者的處理能力大於生產者，那麼消費者就必須等待生產者。為了解決這個問題於是引入了生產者和消費者模式。

2.2 什麼是生產者消費者模式

生產者消費者模式是通過一個容器來解決生產者和消費者的強耦合問題。生產者和消費者彼此之間不直接通訊，而通過阻塞佇列來進行通訊，所以生產者生產完資料之後不用等待消費者處理，直接扔給阻塞佇列，消費者不找生產者要資料，而是直接從阻塞佇列裡取，阻塞佇列就相當於一個緩衝區，平衡了生產者和消費者的處理能力。

2.3 程式碼

2.3.1 基於佇列實現生產者消費者模型

from multiprocessing import Process,Queue
import time,random,os
def consumer(q):
    while True:
        res=q.get()
        time.sleep(random.randint(1,3))
        print('%s 吃 %s' %(os.getpid(),res))

def producer(q):
    for i in range(10):
        time.sleep(random.randint(1,3))
        res='包子%s' %i
        q.put(res)
        print('生產了 %s' %(os.getpid(),res))

if __name__ == '__main__':
    q=Queue()
    #生產者們:即廚師們
    p1=Process(target=producer,args=(q,))

    #消費者們:即吃貨們
    c1=Process(target=consumer,args=(q,))

    #開始
    p1.start()
    c1.start()
    print('主')

此時的問題是主程式永遠不會結束，原因是：生產者p在生產完後就結束了，但是消費者c在取空了q之後，則一直處於死迴圈中且卡在q.get()這一步。

解決方式無非是讓生產者在生產完畢後，往佇列中再發一個結束訊號，這樣消費者在接收到結束訊號後就可以break出死迴圈。

2.3.2 改良版——生產者消費者模型

from multiprocessing import Process,Queue
import time,random,os
def consumer(q):
    while True:
        res=q.get()
        if res is None:break #收到結束訊號則結束
        time.sleep(random.randint(1,3))
        print('%s 吃 %s' %(os.getpid(),res))

def producer(q):
    for i in range(10):
        time.sleep(random.randint(1,3))
        res='包子%s' %i
        q.put(res)
        print('生產了 %s' %(os.getpid(),res))
    q.put(None) #傳送結束訊號
if __name__ == '__main__':
    q=Queue()
    #生產者們:即廚師們
    p1=Process(target=producer,args=(q,))

    #消費者們:即吃貨們
    c1=Process(target=consumer,args=(q,))

    #開始
    p1.start()
    c1.start()
    print('主')

注意：結束訊號None，不一定要由生產者發，主程式裡同樣可以發，但主程式需要等生產者結束後才應該傳送該訊號。

2.3.3 主程式在生產者生產完畢後傳送結束訊號None

from multiprocessing import Process,Queue
import time,random,os
def consumer(q):
    while True:
        res=q.get()
        if res is None:break #收到結束訊號則結束
        time.sleep(random.randint(1,3))
        print('%s 吃 %s' %(os.getpid(),res))

def producer(q):
    for i in range(2):
        time.sleep(random.randint(1,3))
        res='包子%s' %i
        q.put(res)
        print('生產了 %s' %(os.getpid(),res))

if __name__ == '__main__':
    q=Queue()
    #生產者們:即廚師們
    p1=Process(target=producer,args=(q,))

    #消費者們:即吃貨們
    c1=Process(target=consumer,args=(q,))

    #開始
    p1.start()
    c1.start()

    p1.join()
    q.put(None) #傳送結束訊號
    print('主')

但上述解決方式，在有多個生產者和多個消費者時，我們則需要用一個很low的方式去解決

2.3.4 多個消費者的例子：有幾個消費者就需要傳送幾次結束訊號

from multiprocessing import Process,Queue
import time,random,os
def consumer(q):
    while True:
        res=q.get()
        if res is None:break #收到結束訊號則結束
        time.sleep(random.randint(1,3))
        print('%s 吃 %s' %(os.getpid(),res))

def producer(name,q):
    for i in range(2):
        time.sleep(random.randint(1,3))
        res='%s%s' %(name,i)
        q.put(res)
        print('生產了 %s' %(os.getpid(),res))

if __name__ == '__main__':
    q=Queue()
    #生產者們:即廚師們
    p1=Process(target=producer,args=('包子',q))
    p2=Process(target=producer,args=('骨頭',q))
    p3=Process(target=producer,args=('泔水',q))

    #消費者們:即吃貨們
    c1=Process(target=consumer,args=(q,))
    c2=Process(target=consumer,args=(q,))

    #開始
    p1.start()
    p2.start()
    p3.start()
    c1.start()

    p1.join() #必須保證生產者全部生產完畢,才應該傳送結束訊號
    p2.join()
    p3.join()
    q.put(None) #有幾個消費者就應該傳送幾次結束訊號None
    q.put(None) #傳送結束訊號
    print('主')

這時可以用 JoinableQueue([maxsize]) 這個佇列來解決。

三、JoinableQueue([maxsize])

建立可連線的共享程式佇列。這就像是一個Queue物件，但佇列允許專案的使用者通知生產者專案已經被成功處理。通知程式是使用共享的訊號和條件變數來實現的。

3.1.方法介紹

JoinableQueue的例項p除了與Queue物件相同的方法之外，還具有以下方法：

q.task_done()：使用者使用此方法發出訊號，表示q.get()返回的專案已經被處理。如果呼叫此方法的次數大於從佇列中刪除的專案數量，將引發ValueError異常。

q.join()：生產者將使用此方法進行阻塞，直到佇列中所有專案均被處理。阻塞將持續到為佇列中的每個專案均呼叫q.task_done()方法為止。
下面的例子說明如何建立永遠執行的程式，使用和處理佇列上的專案。生產者將專案放入佇列，並等待它們被處理。

3.2.JoinableQueue佇列實現消費之生產者模型

from multiprocessing import Process,JoinableQueue
import time,random,os
def consumer(q):
    while True:
        res=q.get()
        time.sleep(random.randint(1,3))
        print('%s 吃 %s' %(os.getpid(),res))
        q.task_done() #向q.join()傳送一次訊號,證明一個資料已經被取走了

def producer(name,q):
    for i in range(10):
        time.sleep(random.randint(1,3))
        res='%s%s' %(name,i)
        q.put(res)
        print('生產了 %s' %(os.getpid(),res))
    q.join() #生產完畢，使用此方法進行阻塞，直到佇列中所有專案均被處理。


if __name__ == '__main__':
    q=JoinableQueue()
    #生產者們:即廚師們
    p1=Process(target=producer,args=('包子',q))
    p2=Process(target=producer,args=('骨頭',q))
    p3=Process(target=producer,args=('泔水',q))

    #消費者們:即吃貨們
    c1=Process(target=consumer,args=(q,))
    c2=Process(target=consumer,args=(q,))
    c1.daemon=True
    c2.daemon=True

    #開始
    p_l=[p1,p2,p3,c1,c2]
    for p in p_l:
        p.start()

    p1.join()
    p2.join()
    p3.join()
    print('主') 
    
    #主程式等--->p1,p2,p3等---->c1,c2
    #p1,p2,p3結束了,證明c1,c2肯定全都收完了p1,p2,p3發到佇列的資料
    #因而c1,c2也沒有存在的價值了,不需要繼續阻塞在程式中影響主程式了。應該隨著主程式的結束而結束,所以設定成守護程式就可以了。

相關文章