Kdaj se odločiš za threading, multiprocessing ali asyncio?

Question

Accepted Answer

Python ponuja tri modele sočasnosti, izbira pa je odvisna predvsem od tega, ali je vaše delo **I/O-vezano** ali **CPU-vezano** — odločitev je v veliki meri oblikovana s strani GIL-a (ki preprečuje, da bi niti izvajale Python kod vzporedno).

## Trije modeli

```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 — za I/O-vezano sočasnost

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

Niti dobro delujejo za I/O-vezane naloge (omrežje, datoteke, DB), ker se GIL sprosti med čakanjem — več čakanj poteka sočasno. Vendar **ne** pospešijo CPU-vezano delo.

## multiprocessing — za CPU-vezano paralelizem

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

Za CPU-intenzivno delo (obdelava slik, matematika, obdelava podatkov) ločeni procesi zaobidejo en GIL in se resnično izvajajo vzporedno na več jedrah. Cena: višja poraba virov (zagon procesa) in podatki morajo biti **serijalizirani** med procesi (privzeto ni deljene pomnilnika).

## asyncio — za I/O s visoko sočasnostjo

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

asyncio upravlja ogromno število sočasnih I/O operacij na eni niti, bolj učinkovito kot niti (brez porabe na nit) — idealno za strežnike in omrežni kod z visoko sočasnostjo.

## Vodnik za odločanje

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

## Zakaj je to важno

Odbor pravilnega modela sočasnosti je ena najbolj posledičnih odločitev za zmogljivost Python-a, napačna izbira (klasična napaka: niti za CPU-vezano delo, ki ga GIL naredi neuporabnega) pa vodi do kode, ki se ne razširja.

Logika vodenja teče iz GIL-a: **niti/asyncio za I/O-vezano** (GIL se sprosti med čakanjem — sočasnost deluje) in **multiprocessing za CPU-vezano** (ločeni GIL-i za resnični paralelizem), pri čemer je asyncio predpostavljen, ko je sočasnost zelo visoka.

Razumevanje prednosti vsakega modela, stroškov (poraba procesov/serializacija, zahteve knjižnic asyncio) in odločitve I/O-vs-CPU je bistveno za pisanje sočasnega Python-a, ki dejansko pripelje do zmogljivosti.