Pythonのconcurrent.futures完全ガイド:I/OバウンドとCPUバウンドのタスクを高速化する

Python tutorial - IT technology blog
Python tutorial - IT technology blog

背景:forループがボトルネックになるとき

500件のクライアントに対して順番にAPIを呼び出すPythonスクリプトをforループで書いたことがある人なら、その待ち時間の長さを痛感したことがあるはずです。筆者自身もかつて、そのような処理を完了させるためだけに15分以上待たされた経験があります。さらに問題なのは、その間CPUがほとんどアイドル状態(使用率2%未満)だったことです。プロセスの大半の時間は、単に相手サーバーからのレスポンスを待つことだけに費やされていました。

また別のケースでは、数千件のログファイルを解凍してSHA-256ハッシュを計算する必要がありました。このときはCPU使用率が100%まで跳ね上がったものの、使われていたのは1コアだけでした。サーバーの残り7つのコアは完全に遊んでいたのです。

これら2つの問題は、プログラミングにおける典型的な2つの課題を象徴しています。

  • I/Oバウンド(I/O待ち):処理時間の大半がネットワーク通信、ディスクの読み書き、データベースのクエリ待ちなどに費やされるタスク。CPUの計算負荷は高くありません。
  • CPUバウンド(CPU負荷):データの暗号化・ハッシュ計算、画像圧縮、行列演算、機械学習モデルの学習など、CPUがフル稼働して計算し続けるタスク。

CPythonにはGIL(Global Interpreter Lock)という仕組みが存在します。このロックによって、複数の物理CPUコア上でPythonのバイトコードが同時に実行されるのを防いでいます。そのため、Pythonにおけるマルチスレッドは重い計算処理の高速化には役立ちません。しかし、スレッドがI/Oタスク(HTTPリクエスト送信など)に遭遇すると、自ら進んでGILを解放し、他のスレッドを実行できるようにします。

従来、開発者はthreadingやmultiprocessingモジュールを手動で扱う必要がありました。しかし、Queueの管理、プロセス間での例外処理、デッドロックの回避などを自前で行うのは非常にバグを生みやすいものでした。

Python 3.2で登場したconcurrent.futuresモジュールは、まさにこの課題を解決するためのものです。統一された高水準インターフェースを提供し、Worker Poolを自動管理して、Futureオブジェクトを介して結果をきれいに集約してくれます。

検証環境のセットアップ

concurrent.futuresモジュールはPython標準ライブラリに含まれているため、追加のインストールは不要です。本記事でのベンチマーク検証をスムーズに行うために、requestsとtqdmライブラリをインストールしておきましょう。

# 仮想環境の作成と有効化
python3 -m venv venv
source venv/bin/activate  # Windowsの場合: venv\Scripts\activate

# HTTPリクエストと進捗バー表示用のライブラリをインストール
pip install requests tqdm

ThreadPoolExecutorとProcessPoolExecutor:どちらを使うべきか?

このモジュールはExecutorを継承した2つの主要な実行クラスを提供しています。課題に応じて適切なツールを選択できるかどうかが、スクリプトの実行速度を大きく左右します。

1. ThreadPoolExecutorでI/Oバウンドなタスクを処理する

ThreadPoolExecutorは、ファイルのダウンロード、Webスクレイピング、Webhookの呼び出しなどのタスクに適しています。各スレッドは親プロセスのメモリ空間を共有するため、起動オーバーヘッドが非常に低いのが特徴です。

最も重要なパラメータはmax_workersです。Python 3.8以降、デフォルト値はmin(32, (os.cpu_count() or 1) + 4)として計算されます。レイテンシが高いHTTPレスポンスを待つタスクの場合、接続先サーバーのレートリミットを超えない範囲で、この値を20〜50ワーカー程度まで増やすことができます。

submit()メソッドとas_completed()を組み合わせることで、リスト全体が完了するのを待つことなく、ワーカーが処理を終えた順にすぐ結果を取得できます。

import time
import requests
from concurrent.futures import ThreadPoolExecutor, as_completed

URLS = [
    "https://httpbin.org/delay/1",
    "https://httpbin.org/delay/2",
    "https://httpbin.org/delay/1",
    "https://httpbin.org/status/404",
    "https://httpbin.org/delay/1",
]

def fetch_url(url, timeout=5):
    response = requests.get(url, timeout=timeout)
    return url, response.status_code

start_time = time.perf_counter()

# 5つのスレッドを並行実行するプールを初期化
with ThreadPoolExecutor(max_workers=5) as executor:
    future_to_url = {executor.submit(fetch_url, url): url for url in URLS}
    
    for future in as_completed(future_to_url):
        url = future_to_url[future]
        try:
            target_url, status = future.result()
            print(f"[完了] {target_url} -> HTTP {status}")
        except Exception as exc:
            print(f"[エラー] {url} で例外が発生: {exc}")

elapsed = time.perf_counter() - start_time
print(f"実行時間: {elapsed:.2f} 秒")

順次実行した場合、少なくとも 1 + 2 + 1 + 0.1 + 1 ≈ 5.1秒かかります。しかし5つのワーカーで並行実行すると、合計実行時間はわずか約2.1〜2.3秒に短縮され、最も遅延の大きいリクエストの所要時間とほぼ同等になります。

2. ProcessPoolExecutorでGILの壁を破り、CPUバウンドを処理する

暗号ハッシュ計算、ファイル圧縮、画像処理などを行う場合、GILの影響で通常のマルチスレッドは効果を発揮しません。ProcessPoolExecutorは、処理を複数の独立したプロセスに分割することでこの問題を解決します。各プロセスが個別のPythonインタプリタとメモリ領域を持つため、各CPUコアのリソースを100%活用できます。

注意:max_workersには実際のコア数(os.cpu_count())を設定することをおすすめします。プロセス数を増やしすぎると、OSによるコンテキストスイッチやプロセス間通信(IPC)のオーバーヘッドが増大し、かえって逆効果になります。

import hashlib
import os
import time
from concurrent.futures import ProcessPoolExecutor

def heavy_hashing_task(number):
    """CPUサイクルを大量に消費する高負荷タスクのシミュレーション"""
    data = str(number).encode('utf-8')
    for _ in range(2_000_000):
        data = hashlib.sha256(data).digest()
    return number, data.hex()[:10]

# Windows/macOSでのフォーク無限ループを防ぐため、__main__のチェックが必須
if __name__ == '__main__':
    numbers = [10001, 10002, 10003, 10004, 10005, 10006, 10007, 10008]
    cores = os.cpu_count() or 4
    print(f"検出されたCPUコア数: {cores}")

    start_time = time.perf_counter()

    with ProcessPoolExecutor(max_workers=cores) as executor:
        results = list(executor.map(heavy_hashing_task, numbers))

    for num, hashed in results:
        print(f"値 {num} -> ハッシュ: {hashed}")

    print(f"完了時間: {time.perf_counter() - start_time:.2f} 秒")

エラーハンドリングと進捗監視

並行処理コードを本番システムに導入する際は、堅牢なエラーハンドリング機構が不可欠です。適切に制御されていないと、1つのワーカーがハングアップしただけでプロセス全体が機能不全に陥る可能性があります。

1. タイムアウトを明示的に設定する

デフォルトでは、future.result()はタスクが完了するまでプログラムをブロックします。無限に待ち続ける事態を防ぐため、必ずtimeoutの値を指定しましょう。

from concurrent.futures import TimeoutError

try:
    # このタスクの上限を3秒に設定
    result = future.result(timeout=3)
except TimeoutError:
    print("タスクが3秒を超過したため、結果を破棄します!")
    # cancel() はタスクがキューで待機中の場合のみキャンセル可能(実行開始後は不可)
    future.cancel()

2. tqdmで進捗状況を可視化する

数千件ものレコードを処理する場合、ターミナルにログを延々と出力し続けると進捗の把握が困難になります。as_completedをtqdmでラップすることで、直感的なプログレスバーを表示できます。

from tqdm import tqdm

with ThreadPoolExecutor(max_workers=8) as executor:
    futures = [executor.submit(fetch_url, url) for url in URLS]
    
    for f in tqdm(as_completed(futures), total=len(futures), desc="リクエスト処理中"):
        try:
            res = f.result()
        except Exception as err:
            pass

3. ベストプラクティスのまとめ

  1. I/Oバウンド(API、ネットワーク、ディスク):ThreadPoolExecutorを選択。インフラ環境に応じてmax_workersを10〜32程度に設定します。
  2. CPUバウンド(暗号化、画像処理):ProcessPoolExecutorを選択。マシンのCPUコア数に合わせてmax_workersを設定します。
  3. シリアライズ可能性(Pickle):ProcessPoolExecutorに渡す関数や引数は、すべてpickle可能(シリアライズ可能)である必要があります。オープン中のファイル記述子、ソケット、データベース接続などのオブジェクトを子プロセスに渡すことは絶対に避けてください。
  4. リソースの解放:常にwithブロックを使用してください。ブロックを抜ける際、コンテキストマネージャーが自動的にexecutor.shutdown(wait=True)を呼び出し、システムリソースのリークを防ぎます。
Share: