Python 日誌管理與多執行緒/多程式設計實務案例

– 7 分鐘閱讀

現代軟體開發中，有效地記錄程式執行狀態和利用多核心提升效能至關重要。本文將探討如何在 Python 中結合日誌管理與多執行緒/多程式設計，使應用程式更穩定、高效。首先，logging 模組提供強大的日誌記錄功能，可以設定不同處理器將日誌訊息輸出到檔案、控制檯等。threading 模組適用於 I/O 密集型任務，而 multiprocessing 模組則更適合 CPU 密集型任務，能充分利用多核心優勢。concurrent.futures 模組簡化了多執行緒和多程式的管理，提供更便捷的介面。實務上，常使用 QueueHandler 和 QueueListener 實作非同步日誌記錄，避免日誌操作阻塞主程式流程。程式碼範例中，示範瞭如何組態日誌格式、處理器，以及如何在多程式環境下使用佇列分享日誌訊息，並以非同步方式寫入檔案。此外，還需考量錯誤處理、資源管理和效能最佳化等導向，例如，完善的錯誤處理機制能確保程式在異常情況下仍能記錄關鍵資訊；合理的資源組態能避免資源洩漏和競爭；針對不同應用場景調整程式/執行緒數量和資料結構能進一步提升效能。

多執行緒與多工程設計：實務案例分析

在現代軟體開發中，日誌管理與多執行緒/多工程設計是兩個不可或缺的技術領域。透過適當的日誌管理，我們可以有效地追蹤應用程式的執行狀態，而多執行緒與多工程設計則能提升應用程式的效能與可擴充套件性。以下玄貓將探討如何在 Python 中實作這兩者的結合，並提供具體的實務案例。

日誌管理與多執行緒/多工程設計的基本概念

日誌管理是指將應用程式的執行狀態、錯誤資訊等記錄下來，以便後續的排錯和分析。Python 的 logging 模組提供了強大的日誌管理功能，可以靈活地組態不同的日誌處理器（handler）來處理日誌資訊。常見的處理器包括 FileHandler、RotatingFileHandler 等，這些處理器可以將日誌寫入檔案、控制檯或其他目標。

而多執行緒與多工程設計則是利用多核心處理器來提升應用程式的平行處理能力。Python 提供了 threading 和 multiprocessing 模組來支援多執行緒和多工程設計。其中，threading 模組適合於 I/O 密集型任務，而 multiprocessing 模組則適合於 CPU 密集型任務。

日誌管理的實作

首先，玄貓來介紹如何在 Python 中實作日誌管理。以下是一個簡單的例子，展示如何使用 logging 模組來記錄日誌資訊：

import logging

def setup_logging():
    logger = logging.getLogger()
    handler = logging.FileHandler('app.log')
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    handler.setFormatter(formatter)
    logger.addHandler(handler)
    logger.setLevel(logging.DEBUG)

setup_logging()
logger = logging.getLogger(__name__)
logger.debug('This is a debug message')
logger.info('This is an info message')
logger.warning('This is a warning message')
logger.error('This is an error message')
logger.critical('This is a critical message')

內容解密：

  • 日誌初始化：首先，我們定義了一個 setup_logging() 函式來初始化日誌組態。這個函式建立了一個 FileHandler 來將日誌寫入到 app.log 檔案中。
  • 格式化器：接著，我們建立了一個 Formatter 物件來定義日誌資訊的格式。這裡我們使用了 %(asctime)s、%(name)s、%(levelname)s 和 %(message)s 這些格式化字串來展示日誌資訊。
  • 設定處理器：然後，我們將格式化器設定到處理器中，並將處理器新增到根日誌物件中。
  • 設定日誌級別：最後，我們設定了日誌級別為 DEBUG，這樣所有級別的日誌資訊都會被記錄下來。
  • 記錄日誌：在函式外部，我們建立了一個名為 __name__ 的日誌物件，並使用不同的日誌級別來記錄幾條日誌資訊。

多執行緒與多工程設計

接下來，玄貓將介紹如何在 Python 中實作多執行緒與多工程設計。以下是一個簡單的例子，展示如何使用 multiprocessing 模組來建立多個工作程式：

import multiprocessing
import time
import random

def worker(name):
    print(f'Worker {name} started')
    time.sleep(random.randint(1, 5))
    print(f'Worker {name} finished')

if __name__ == '__main__':
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(i,))
        processes.append(p)
        p.start()

    for p in processes:
        p.join()

內容解密：

  • 定義工作函式：首先，我們定義了一個 worker() 函式來模擬工作程式。這個函式接受一個引數 name 作為工作程式的名稱。
  • 建立程式：在 __main__ 塊中，我們建立了一個空列表 processes 來儲存所有的工作程式。
  • 啟動程式：然後，我們使用一個迴圈建立了 5 個工作程式，並將它們新增到列表中並啟動。
  • 等待程式完成：最後，我們使用另一個迴圈呼叫每個工作程式的 join() 方法來等待它們完成。

日誌管理與多程式設計

在實際開發中，我們經常需要將日誌管理與多執行緒/多工程設計結合起來。以下是一個具體案例展示如何實作這兩者的結合：

import logging
import logging.handlers
import multiprocessing
import time
import random

def setup_logging(queue):
    handler = logging.handlers.QueueHandler(queue)
    root = logging.getLogger()
    root.addHandler(handler)
    root.setLevel(logging.DEBUG)

def listener_process(queue):
    setup_logging(queue)
    while True:
        log_record = queue.get()
        if log_record is None:
            break
        logger = logging.getLogger(log_record.name)
        logger.handle(log_record)

def worker_process(queue):
    setup_logging(queue)
    logger = logging.getLogger(__name__)
    for _ in range(10):
        time.sleep(random.randint(1, 5))
        logger.info(f'Worker process {multiprocessing.current_process().name} is running')

if __name__ == '__main__':
    queue = multiprocessing.Queue()
    listener = multiprocessing.Process(target=listener_process, args=(queue,))
    listener.start()

    workers = []
    for _ in range(5):
        worker = multiprocessing.Process(target=worker_process, args=(queue,))
        workers.append(worker)
        worker.start()

    for worker in workers:
        worker.join()

    queue.put(None)
    listener.join()

內容解密：

  • 設定日誌處理器：首先玄貓定義了一個 setup_logging() 函式來為每個程式組態一個佇列處理器（QueueHandler），將所有程式中的日誌記錄傳送到佇列中。
  • 監聽程式：然後玄貓定義了一個監聽程式（listener_process），該程式從佇列中取得日誌記錄並處理它們。這裡我們使用了無限迴圈來不斷取得佇列中的日誌記錄並處理它們。
  • 工作程式：接著玄貓定義了一個工作程式（worker_process），該程式模擬一些任務並記錄相應的日誌資訊。
  • 主函式：最後玄貓在主函式中建立了一個佇列物件、一個監聽程式和五個工作程式。啟動這些程式後將會產生相關操作流向佇列。
  • 保持執行狀態：主函式保持執行狀態直到所有工作程式完成後再將結束標記放入佇列並結束監聽程式。

日誌管理與執行緒設計

同樣地，也可以結合執行緒進行最佳化：

import logging
import logging.handlers
import threading
import multiprocessing
import time
import random

def setup_logging(queue):
    handler = logging.handlers.QueueHandler(queue)
    root = logging.getLogger()
    root.addHandler(handler)
    root.setLevel(logging.DEBUG)

def listener_thread(queue):
    while True:
        log_record = queue.get()
        if log_record is None:
            break
        logger = logging.getLogger(log_record.name)
        logger.handle(log_record)

def worker_process(queue):
    setup_logging(queue)
    logger = logging.getLogger(__name__)
    for _ in range(10):
        time.sleep(random.randint(1, 5))
        logger.info(f'Worker process {multiprocessing.current_process().name} is running')

if __name__ == '__main__':
    queue = multiprocessing.Queue()
    listener = threading.Thread(target=listener_thread, args=(queue,))
    listener.start()

    workers = []
    for _ in range(5):
        worker = multiprocessing.Process(target=worker_process, args=(queue,))
        workers.append(worker)
        worker.start()

    for worker in workers:
        worker.join()

    queue.put(None)
    listener.join()

內容解密：

  • 設定監聽執行緒：我們首先建立一個監聽執行緒（listener_thread）來從佇列中取得和處理日誌記錄。
  • 調整程式碼結構：我們透過對原有程式碼結構進行適當調整來實作與執行緒設計結合。

概述及總結

透過以上案例分析可以看到：Python 的 logging 模組和 multiprocessing/threading 模組提供了強大且靈活的工具來進行日誌管理和平行計算。透過適當地結合這些技術，可以顯著提升應用程度式的穩定性、效能和可擴充套件性。

未來趨勢方面：

  1. 日誌管理：未來可能會有更加智慧化、自動化地分析和處理機制；
  2. 處理器架構：隨著新硬體架構不斷湧現（如量子計算），軟體開發必須跟上技術變遷。

希望以上內容對於大家理解 Python 中如何有效地進行 日誌管理及平行計算具有幫助！

使用 Python 進行日誌與平行處理

在現代軟體開發中，日誌記錄和平行處理是兩個不可或缺的技術。日誌記錄幫助我們追蹤系統執行狀態，而平行處理則能顯著提升程式的效能。本篇文章將探討如何使用 Python 進行日誌記錄和平行處理，並提供具體的程式碼範例及詳細解說。

日誌記錄組態

首先，我們需要組態日誌記錄系統。在 Python 中，這可以透過 logging 模組來實作。以下是一個典型的日誌記錄組態範例：

# settings.py

LOGGING_CONFIG = {
    "version": 1,
    "formatters": {
        "detailed": {
            "class": "logging.Formatter",
            "format": "%(asctime)s %(name)-15s %(levelname)-8s %(processName)-10s %(message)s",
        }
    },
    "handlers": {
        "console": {
            "class": "logging.StreamHandler",
            "level": "INFO",
        },
        "file": {
            "class": "logging.FileHandler",
            "filename": "thread_and_process.log",
            "mode": "w",
            "formatter": "detailed",
        },
        "pyfile": {
            "class": "logging.FileHandler",
            "filename": "thread_and_process-py.log",
            "mode": "w",
            "formatter": "detailed",
        },
        "errors": {
            "class": "logging.FileHandler",
            "filename": "thread_and_process-errors.log",
            "mode": "w",
            "level": "ERROR",
            "formatter": "detailed",
        },
    },
    "loggers": {"py": {"handlers": ["pyfile"]}},
    "root": {"level": "DEBUG", "handlers": ["console", "file", "errors"]},
}

內容解密：

這段程式碼定義了一個日誌記錄組態，包含格式化器、處理器和記錄器。格式化器用於定義日誌記錄的格式，處理器用於定義日誌記錄的輸出目的地（如控制檯、檔案等），而記錄器則用於將日誌訊息傳遞給處理器。

使用 concurrent.futures 模組

Python 提供了一個方便的模組 concurrent.futures，用於簡化多執行緒和多程式的使用。以下是如何將前面的日誌記錄組態與 concurrent.futures 模組結合使用的範例：

# futures_thread_and_process.py

import concurrent.futures
import logging
import logging.config
import logging.handlers
import multiprocessing
import random
import threading
import time
import settings

def main():
    queue = multiprocessing.Manager().Queue(-1)

    with concurrent.futures.ProcessPoolExecutor(max_workers=10) as executor:
        for i in range(10):
            executor.submit(worker_process, queue)

    listener_process = threading.Thread(
        target=logger_thread,
        args=(queue, )
    )

    listener_process.start()
    time.sleep(3)
    queue.put(None)
    listener_process.join()

內容解密：

這段程式碼展示瞭如何使用 concurrent.futures.ProcessPoolExecutor 來管理多個程式。multiprocessing.Manager().Queue(-1) 建立了一個管理器佇列，這樣可以在不同程式之間分享資料。concurrent.futures.ProcessPoolExecutor 建立了一個程式池，其中包含十個工作執行緒。

非同步日誌記錄

Python 的 asyncio 函式庫提供了非同步支援，但標準的 logging 模組是同步的。為了實作非同步日誌記錄，我們可以使用 QueueHandler 和 QueueListener。以下是一個完整的非同步日誌記錄範例：

# async_logging.py

import asyncio
import logging
import logging.handlers
import random
from queue import SimpleQueue

MESSAGES = ["working hard", "taking a nap", "ERROR, ERROR, ERROR", "processing..."]

async def setup_logging():
    log_queue = SimpleQueue()
    root = logging.getLogger()
    root.setLevel(logging.DEBUG)

    queue_handler = logging.handlers.QueueHandler(log_queue)
    root.addHandler(queue_handler)

    file_handler = logging.FileHandler("queued.log")
    formatter = logging.Formatter(
        ("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
    )
    file_handler.setFormatter(formatter)

    listener = logging.handlers.QueueListener(log_queue, file_handler)

    try:
        listener.start()
        logging.debug("Async logging started")
        while True:
            await asyncio.sleep(60)
    finally:
        logging.debug("Logger is being shut down!")
        listener.stop()

async def task(number):
    logging.info(f"Starting task #{number}")
    await asyncio.sleep(random.randint(1, 5))
    msg = random.choice(MESSAGES)
    logging.info(f"Task {number} is {msg}")
    logging.info(f"Task #{number} is finished")

async def main():
    asyncio.create_task(setup_logging())
    await asyncio.sleep(0.1)

    logging.info("Main function started")

    async with asyncio.TaskGroup() as group:
        for t in range(10):
            group.create_task(task(t))

    logging.info("All work done")

if __name__ == "__main__":
    asyncio.run(main())

內容解密：

這段程式碼展示瞭如何使用 asyncio 和 logging.handlers.QueueHandler 來實作非同步日誌記錄。SimpleQueue 用於在不同協程之間傳遞日誌訊息，而 logging.handlers.QueueListener 則負責將這些訊息寫入檔案中。這樣可以確保日誌記錄不會阻塞協程的執行。

必要進一步改進及考量

  • 錯誤處理：在實際應用中，應該加強錯誤處理機制，確保即使出現異常情況也能正確記錄日誌。
  • 資源管理：在高平行度下，資源管理顯得尤為重要。應該注意避免資源洩漏和競爭條件。
  • 效能最佳化：根據具體應用場景，可能需要進行效能最佳化，如調整程式/執行緒數量、最佳化資料結構等。
內容解密：

此圖示展示了主執行緒如何建立子執行緒和子程式，以及它們之間分享和獨立資源的關係。子執行緒分享主執行緒的資源，而子程式則擁有獨立的資源空間。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。