萬盛學電腦網

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

Python 線程池從原理到生產級實現全解析

為什麼需要線程池?

頻繁創建/銷毀線程開銷大(內核對象、棧內存、上下文切換),且無限制創建會耗盡系統資源導致崩潰。線程池核心價值:

  • 複用線程:工作線程常駐,從任務隊列取任務執行。
  • 限制併發:固定線程數,防止雪崩。
  • 解耦提交與執行:生產者提交任務,消費者線程異步執行。
  • 統一異常/生命周期管理:優雅關閉、異常捕獲、監控指標。

核心組件架構


+----------------+      put(task)      +------------------+
|  Producer      | ------------------> |  Task Queue      |  (thread-safe, blocking)
|  (Main Thread) |                     |  (Queue.Queue)   |
+----------------+                     +--------+---------+
                                          |
                    +---------------------+---------------------+
                    |                     |                     |
              +-----v-----+         +-----v-----+         +-----v-----+
              | Worker 1  |         | Worker 2  |  ...    | Worker N  |
              | (Thread)  |         | (Thread)  |         | (Thread)  |
              +-----------+         +-----------+         +-----------+
                    |                     |                     |
              get(task)             get(task)             get(task)
                    |                     |                     |
              run(task)             run(task)             run(task)

教學版:最小可用線程池(參考原文思路)


import threading
import queue
import time
import signal
import os
from typing import Callable, Any, Optional

class Task:
    """任務封裝"""
    __slots__ = ('func', 'args', 'kwargs')
    def __init__(self, func: Callable, *args, **kwargs):
        self.func = func
        self.args = args
        self.kwargs = kwargs

class ThreadPool:
    """簡易線程池:固定線程數 + 隊列 + 優雅關閉"""
    
    def __init__(self, num_workers: int, max_queue_size: int = 0):
        self.task_queue = queue.Queue(maxsize=max_queue_size)  # 0=無界
        self.workers = []
        self._shutdown = False
        self._shutdown_lock = threading.Lock()
        
        for i in range(num_workers):
            t = threading.Thread(target=self._worker_loop, name=f'Worker-{i}', daemon=True)
            t.start()
            self.workers.append(t)
    
    def _worker_loop(self) -> None:
        while True:
            try:
                task = self.task_queue.get(timeout=0.5)  # 定期檢查關閉標誌
                if task is None:  # 停止信號
                    self.task_queue.task_done()
                    break
                try:
                    task.func(*task.args, **task.kwargs)
                except Exception as e:
                    # 生產環境應接入日誌/監控
                    print(f"[{threading.current_thread().name}] 任務異常: {e}")
                finally:
                    self.task_queue.task_done()
            except queue.Empty:
                with self._shutdown_lock:
                    if self._shutdown:
                        break
    
    def submit(self, func: Callable, *args, **kwargs) -> None:
        """提交任務(非阻塞,隊列滿時阻塞)"""
        with self._shutdown_lock:
            if self._shutdown:
                raise RuntimeError("線程池已關閉")
        self.task_queue.put(Task(func, *args, **kwargs))
    
    def shutdown(self, wait: bool = True) -> None:
        """優雅關閉"""
        with self._shutdown_lock:
            if self._shutdown:
                return
            self._shutdown = True
        # 發送停止信號給每個工作線程
        for _ in self.workers:
            self.task_queue.put(None)
        if wait:
            for t in self.workers:
                t.join()
    
    def __enter__(self) -> 'ThreadPool':
        return self
    
    def __exit__(self, *args) -> None:
        self.shutdown(wait=True)

# 測試
def demo_task(name: str, delay: float):
    print(f"[{threading.current_thread().name}] 開始 {name}")
    time.sleep(delay)
    print(f"[{threading.current_thread().name}] 完成 {name}")

if __name__ == '__main__':
    with ThreadPool(3) as pool:
        for i in range(10):
            pool.submit(demo_task, f"Task-{i}", 0.5)
    print("所有任務完成")

生產級增強:concurrent.futures.ThreadPoolExecutor

Python 3.2+ 內建的**標準、高性能、功能完整**線程池實現,**強烈推薦直接使用**。


from concurrent.futures import ThreadPoolExecutor, as_completed, Future
import time
import logging

logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(threadName)s] %(message)s')
logger = logging.getLogger(__name__)

def io_task(name: str, delay: float) -> str:
    time.sleep(delay)
    return f"Result of {name}"

def main():
    # 固定 4 個工作線程
    with ThreadPoolExecutor(max_workers=4, thread_name_prefix='MyPool') as executor:
        # 1. 提交任務獲取 Future
        futures = {executor.submit(io_task, f'Task-{i}', 0.5): i for i in range(8)}
        
        # 2. 異步獲取結果(按完成順序)
        for future in as_completed(futures):
            idx = futures[future]
            try:
                result = future.result(timeout=10)
                logger.info(f"Task-{idx} 完成: {result}")
            except Exception as e:
                logger.error(f"Task-{idx} 失敗: {e}")
        
        # 3. map 批量提交(保持輸入順序返回結果)
        results = executor.map(io_task, [f'Map-{i}' for i in range(5)], [0.2]*5)
        for i, r in enumerate(results):
            logger.info(f"Map-{i}: {r}")
        
        # 4. 等待所有任務完成(可選)
        # executor.shutdown(wait=True)  # with 塊自動調用

if __name__ == '__main__':
    main()

ThreadPoolExecutor 核心優勢

進階模式:生產者-消費者 + 背壓控制


import queue
import threading
from dataclasses import dataclass
from typing import Generic, TypeVar

T = TypeVar('T')
R = TypeVar('R')

@dataclass
class WorkItem(Generic[T]):
    payload: T
    future: 'Future[R]'  # 用於返回結果給調用者

class BoundedThreadPool(Generic[T, R]):
    """帶背壓控制的線程池:隊列滿時 submit 阻塞,防止 OOM"""
    
    def __init__(self, workers: int, max_queue: int, processor: Callable[[T], R]):
        self.queue = queue.Queue(maxsize=max_queue)
        self.processor = processor
        self.workers = [
            threading.Thread(target=self._run, name=f'Worker-{i}', daemon=True)
            for i in range(workers)
        ]
        for t in self.workers:
            t.start()
    
    def _run(self):
        while True:
            item = self.queue.get()
            if item is None:
                self.queue.task_done()
                break
            try:
                result = self.processor(item.payload)
                item.future.set_result(result)
            except Exception as e:
                item.future.set_exception(e)
            finally:
                self.queue.task_done()
    
    def submit(self, payload: T) -> 'Future[R]':
        from concurrent.futures import Future
        fut = Future()
        self.queue.put(WorkItem(payload, fut))  # 隊列滿時自動阻塞(背壓)
        return fut
    
    def shutdown(self, wait=True):
        for _ in self.workers:
            self.queue.put(None)
        if wait:
            for t in self.workers:
                t.join()

# 使用:處理函數簽名固定,提交只需傳 payload
def process_order(order_id: str) -> dict:
    # 模擬處理訂單
    return {'order_id': order_id, 'status': 'processed'}

pool = BoundedThreadPool(workers=4, max_queue=100, processor=process_order)
futures = [pool.submit(f"ORD-{i}") for i in range(200)]
for f in futures:
    print(f.result())
pool.shutdown()

避坑指南

  1. GIL 限制:CPU 密集型任務(計算、壓縮、圖像處理)用線程池**無法利用多核**,必須改用 ProcessPoolExecutor(多進程,各自獨立 GIL)。
  2. 線程安全:共享數據需用 `threading.Lock`、`RLock`、`queue.Queue`、`concurrent.futures` 內建同步原語。
  3. 異常吞沒:自定義線程池務必在 `run()` 外層 `try/except` 並記錄日誌,否則異常靜默丟失。
  4. 優雅關閉:發送哨兵值(`None`)或調用 `shutdown(wait=True)`,確保隊列任務處理完畢再退出。
  5. 守護線程陷阱:`daemon=True` 會在主線程退出時強制殺死工作線程,導致任務中斷、數據不一致。**生產環境通常設 `daemon=False` 並顯式調用 shutdown**。

總結

  • **學習原理**:手寫簡易線程池理解「隊列 + 工作線程 + 同步 + 生命周期」。
  • **實際項目**:**直接使用 `concurrent.futures.ThreadPoolExecutor`**,標準庫、無依賴、功能完備、經過海量生產驗證。
  • **IO 密集型**(網絡請求、文件讀寫、數據庫查詢)→ 線程池。
  • **CPU 密集型**(計算、編碼、加密)→ 進程池 `ProcessPoolExecutor` 或異步 IO (`asyncio` + 線程池執行器)。
  • 封裝業務邏輯為無狀態可調用對象,配合 `Future` 實現異步編排、超時控制、錯誤處理、監控指標收集。
copyright © 萬盛學電腦網 all rights reserved
特性說明
Future 對象代表異步計算結果,支持 result(), exception(), cancel(), done(), add_done_callback()
異常傳播工作線程異常自動捕獲,調用 future.result() 時重新拋出
超時控制future.result(timeout), as_completed(fs, timeout)
回調機制future.add_done_callback(fn) 完成時自動觸發
線程名稱前綴thread_name_prefix 便於日誌追蹤
上下文管理器with 塊自動 shutdown(wait=True)
可擴展繼承 Executor 實現進程池 ProcessPoolExecutor 同接口