Mikor választod a threading-et, multiprocessing-et vagy asyncio-t?

Question

Accepted Answer

A Python három konkurencia modellt kínál, és a helyes választás főként attól függ, hogy a munkád **I/O-bound** vagy **CPU-bound** — egy döntés, amelyet nagymértékben befolyásol a GIL (amely megakadályozza, hogy a szálak Python kódot párhuzamosan futtassanak).

## A három modell

```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-bound konkurenciához

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

A szálak jól működnek I/O-bound feladatokhoz (hálózat, fájlok, DB), mert a GIL felszabadul várakozás közben — több várakozás párhuzamosan halad. **Soha** nem gyorsítják fel a CPU-bound munkát.

## multiprocessing — CPU-bound párhuzamossághoz

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

A CPU-igényes munkához (képfeldolgozás, matematika, adatfeldolgozás) a külön folyamatok megkerülik az egyetlen GIL-t és valóban párhuzamosan futnak több magra. A költség: nagyobb terhelés (folyamat indítása) és az adatokat **szerializálni** kell a folyamatok között (alapértelmezés szerint nincs megosztott memória).

## asyncio — magas konkurenciás I/O-hoz

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

Az asyncio hatalmas számú egyidejű I/O műveletet kezel egy szálon, hatékonyabban, mint a szálak (nincs szál-per terhelés) — ideális szerverekhez és magas konkurenciás hálózati kódhoz.

## A döntési útmutató

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

## Miért fontos

A helyes konkurencia modell kiválasztása a Python teljesítmény egyik legfontosabb döntése, és a rossz választás (a klasszikus hiba: szálak CPU-bound munkához, amelyet a GIL használhatatlanná tesz) olyan kódhoz vezet, amely nem skálázódik.

A vezetési logika a GIL-ből folyik: **szálak/asyncio I/O-bound-hoz** (GIL felszabadul várakozás alatt — a konkurencia működik) és **multiprocessing CPU-bound-hoz** (külön GIL-ek valós párhuzamossághoz), az asyncio előnyben részesített, ha a konkurencia nagyon magas.

Az egyes modellek erősségeinek, költségeinek (folyamat terhelés/szerializálás, asyncio könyvtári követelményei) és az I/O-vs-CPU döntés megértése elengedhetetlen a konkurens Python írásához, amely valóban teljesítményt nyújt.