萬盛學電腦網

您现在的位置: 萬盛學電腦網 >> 程式設計 >  >> 網路程式設計 >> 程式語言綜合

Python 多線程與 Queue 隊列實戰:生產者-消費者模式完整實現

核心場景

生產者線程定期生成數據放入隊列,消費者線程從隊列取出數據處理。queue.Queue 為線程安全、可阻塞的 FIFO 隊列,是線程間通信的首選。

完整可運行代碼 (Python 3)

#!/usr/bin/env python3
import time
import threading
import queue

# ==================== 生產者 ====================
class Producer(threading.Thread):
    def __init__(self, work_queue, interval=1.0):
        super().__init__(daemon=True)  # 守護線程,主線程退出自動結束
        self.work_queue = work_queue
        self.interval = interval
        self.counter = 1
    
    def run(self):
        while True:
            self.work_queue.put(self.counter)
            print(f"[生產] 放入: {self.counter}, 隊列大小: {self.work_queue.qsize()}")
            self.counter += 1
            time.sleep(self.interval)

# ==================== 消費者 ====================
class Consumer(threading.Thread):
    def __init__(self, work_queue):
        super().__init__(daemon=True)
        self.work_queue = work_queue
    
    def run(self):
        while True:
            # get() 會阻塞直到有數據
            item = self.work_queue.get()
            print(f"[消費] 取出: {item}, 剩餘: {self.work_queue.qsize()}")
            # 處理業務邏輯...
            # 關鍵:標記任務完成,配合 join() 使用
            self.work_queue.task_done()

# ==================== 主程序 ====================
def main():
    work_queue = queue.Queue(maxsize=10)  # 可選:限制隊列大小,防止內存暴漲
    
    producer = Producer(work_queue, interval=1.0)
    consumer = Consumer(work_queue)
    
    producer.start()
    consumer.start()
    
    try:
        # 主線程等待所有任務完成 (需配合 task_done)
        # 此處生產者無限循環,join() 會永久阻塞
        # 實際應用中需有停止條件
        work_queue.join()
    except KeyboardInterrupt:
        print("\n收到中斷信號,正在關閉...")
    finally:
        print("程序結束")

if __name__ == '__main__':
    main()

關鍵機制深度解析

1. Queue 線程安全保證

  • 內部使用 threading.Lock + threading.Condition 實現原子操作。
  • put():隊列滿時阻塞 (可選 timeout),可用時放入並 notify() 消費者。
  • get():隊列空時阻塞,有數據時取出並 notify() 生產者。
  • task_done():每次 get() 後必須調用,配合 join() 計數未完成任務數。

2. 守護線程 daemon=True

  • 主線程結束時,守護線程被強制終止 (不執行 finally、with 清理)。
  • 適用於後台服務、監控、心跳等非關鍵任務。
  • 關鍵業務線程 (如寫入數據庫) 應設 daemon=False (默認) 並顯式 join() 等待。

3. 优雅關閉模式

import threading
import queue

class GracefulProducer(threading.Thread):
    def __init__(self, work_queue, stop_event):
        super().__init__()
        self.work_queue = work_queue
        self.stop_event = stop_event
    
    def run(self):
        i = 0
        while not self.stop_event.is_set():
            self.work_queue.put(i)
            i += 1
            time.sleep(0.5)
        print("生產者收到停止信號,退出")

class GracefulConsumer(threading.Thread):
    def __init__(self, work_queue, stop_event):
        super().__init__()
        self.work_queue = work_queue
        self.stop_event = stop_event
    
    def run(self):
        while not self.stop_event.is_set() or not self.work_queue.empty():
            try:
                item = self.work_queue.get(timeout=0.5)
                print(f"處理: {item}")
                self.work_queue.task_done()
            except queue.Empty:
                continue
        print("消費者隊列清空並收到停止信號,退出")

def main():
    stop_event = threading.Event()
    q = queue.Queue()
    
    p = GracefulProducer(q, stop_event)
    c = GracefulConsumer(q, stop_event)
    p.start(); c.start()
    
    time.sleep(3)
    print("主線程發送停止信號")
    stop_event.set()
    
    p.join(); c.join()
    print("所有線程已優雅退出")

if __name__ == '__main__':
    main()

進階模式

多生產者 / 多消費者

# 啟動多個生產者/消費者線程
producers = [Producer(q) for _ in range(3)]
consumers = [Consumer(q) for _ in range(5)]
for t in producers + consumers:
    t.start()

優先級隊列

import queue
pq = queue.PriorityQueue()
pq.put((2, '低優先級'))
pq.put((1, '高優先級'))  # 元組首元素為優先級,數值越小優先級越高
print(pq.get())  # (1, '高優先級')

異步 IO 替代方案 (高併發 IO 密集型)

import asyncio

async def producer(queue):
    for i in range(10):
        await queue.put(i)
        await asyncio.sleep(0.5)

async def consumer(queue):
    while True:
        item = await queue.get()
        print(f"Async consumed: {item}")
        queue.task_done()

async def main():
    q = asyncio.Queue(maxsize=5)
    await asyncio.gather(producer(q), consumer(q))

asyncio.run(main())

最佳實踐清單

  1. 使用 queue.Queue 而非列表 + 鎖,避免重複造輪子且有 Bug。
  2. 設置 maxsize 防止生產過快導致內存耗盡 (背壓)。
  3. 每次 get() 必配 task_done(),否則 join() 永不返回。
  4. 異常處理:get/put 設置 timeout,捕獲 queue.Empty/Full。
  5. 優雅關閉:用 threading.Event 或特殊「毒丸」對象 (None) 通知線程退出。
  6. CPU 密集型任務改用 multiprocessing.Queue + 進程池。
copyright © 萬盛學電腦網 all rights reserved