Kdy si vyberete threading, multiprocessing nebo asyncio?

Question

Accepted Answer

Python nabízí tři modely souběhu, a správný výběr závisí hlavně na tom, zda je vaše práce **vázaná na I/O** nebo **vázaná na CPU** — rozhodnutí, které je silně ovlivněno GIL (který brání vláknům v paralelním spouštění kódu Python).

## Tři modely

```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 — pro souběh vázaný na 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
```

Vlákna fungují dobře pro úkoly vázané na I/O (síť, soubory, DB), protože GIL je uvolněn při čekání — více čekání postupuje souběžně. **Neurychlují** práci vázanou na CPU.

## multiprocessing — pro paralelismus vázaný na 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
```

Pro práci náročnou na CPU (zpracování obrázků, matematika, zpracování dat) samostatné procesy obcházejí jediný GIL a běží skutečně paralelně na více jádrech. Náklady: vyšší režie (spuštění procesu) a data musí být **serializována** mezi procesy (ve výchozím nastavení žádná sdílená paměť).

## asyncio — pro I/O s vysokou souběžností

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

asyncio zpracovává obrovské množství souběžných I/O operací v jednom vlákně, efektivněji než vlákna (bez režie na vlákno) — ideální pro servery a kód vysoké souběžnosti sítě.

## Průvodce rozhodnutím

```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)
```

## Proč je to důležité

Volba správného modelu souběhu je jedno z nejdůležitějších rozhodnutí o výkonu Python, a chyba v něm (klasická chyba: vlákna pro práci vázanou na CPU, kterou GIL činí zbytečnou) vede ke kódu, který se neškáluje.

Vodící logika vychází z GIL: **vlákna/asyncio pro I/O-bound** (GIL se uvolní během čekání — souběh funguje) a **multiprocessing pro CPU-bound** (samostatné GILy pro skutečný paralelismus), přičemž asyncio je upřednostňováno, když je souběžnost velmi vysoká.

Pochopení silných stránek každého modelu, nákladů (režie procesů/serializace, požadavky knihovny asyncio) a rozhodnutí I/O versus CPU je zásadní pro psaní souběžného Python, který skutečně poskytuje výkon.