threading、multiprocessing、asyncio はどのように使い分けますか？

Question

Accepted Answer

Python には 3 つの並行処理モデルがあり、正しく選ぶには主に処理が **I/O バウンド**か **CPU バウンド**かによります。この判断は GIL（スレッドが Python コードを並列実行するのを妨げる）に大きく左右されます。

## 3 つのモデル

```text
threading        → multiple threads, ONE process. GIL-limited for CPU.
multiprocessing  → multiple PROCESSES, each its own interpreter/GIL → true parallelism.
asyncio          → single thread, cooperative coroutines yielding at await points.
```

## threading — I/O バウンドの並行処理向け

```python
from concurrent.futures import ThreadPoolExecutor

# ✅ good for I/O — the GIL is RELEASED during I/O waits, so waits overlap
with ThreadPoolExecutor(max_workers=10) as ex:
    results = list(ex.map(download_url, urls))   # many downloads concurrently
```

スレッドは I/O バウンドのタスク（ネットワーク、ファイル、DB）に適しています。待機中に GIL が解放されるため、複数の待機が並行して進むからです。CPU バウンドの処理は**高速化しません**。

## multiprocessing — CPU バウンドの並列処理向け

```python
from concurrent.futures import ProcessPoolExecutor

# ✅ good for CPU — separate processes each have their own GIL → use all cores
with ProcessPoolExecutor(max_workers=4) as ex:
    results = list(ex.map(heavy_computation, data))   # genuine parallelism
```

CPU 負荷の高い処理（画像処理、数学計算、データ処理）では、別々のプロセスが単一の GIL を回避し、複数コア上で真に並列実行します。代償として、オーバーヘッドが高く（プロセス起動）、プロセス間でデータを**シリアライズ**する必要があります（デフォルトでは共有メモリがない）。

## asyncio — 高並行 I/O 向け

```python
import asyncio
# ✅ best for MANY concurrent I/O operations (thousands) — lightest weight
await asyncio.gather(*(fetch(url) for url in urls))
```

asyncio は膨大な数の並行 I/O 操作を 1 つのスレッド上で、スレッドよりも効率的に（スレッドごとのオーバーヘッドなし）処理します。サーバーや高並行のネットワークコードに理想的です。

## 判断の指針

```text
CPU-bound (computation)              → multiprocessing
I/O-bound, moderate concurrency      → threading (simple, works with sync libraries)
I/O-bound, HIGH concurrency          → asyncio (thousands of connections, but needs
                                       async-compatible libraries)
Mixed CPU + I/O                       → combine (e.g. asyncio + a process pool for CPU)
```

## なぜ重要なのか

適切な並行処理モデルの選択は、Python における最も重大な性能上の判断の 1 つです。間違える（古典的な間違い: CPU バウンドにスレッドを使い、GIL によって無意味になる）と、スケールしないコードになります。

その指針となるロジックは GIL から導かれます。**I/O バウンドには threading/asyncio**（待機中に GIL が解放されるため並行処理が機能する）、**CPU バウンドには multiprocessing**（真の並列処理のための別々の GIL）であり、並行性が非常に高い場合は asyncio が好まれます。

各モデルの強み、コスト（プロセスのオーバーヘッド/シリアライズ、asyncio のライブラリ要件）、そして I/O vs CPU の判断を理解することは、実際に性能を発揮する並行処理 Python を書くために不可欠です。