Når velger du threading, multiprocessing eller asyncio?

Question

Accepted Answer

Python tilbyr tre concurrency-modeller, og riktig valg avhenger hovedsakelig av om arbeidet ditt er **I/O-bound** eller **CPU-bound** — en beslutning som i stor grad formes av GIL (som hindrer tråder fra å kjøre Python-kode parallelt).

## De tre modellene

```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 — for I/O-bound concurrency

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

Tråder fungerer godt for I/O-bound oppgaver (nettverk, filer, DB) fordi GIL frigjøres under venting — flere venter kan foregå samtidig. De **akselererer ikke** CPU-bound arbeid.

## multiprocessing — for CPU-bound parallellisme

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

For CPU-tungt arbeid (bildeprosessering, matematikk, databehandling) omgår separate prosesser den enkle GIL og kjører virkelig parallelt på flere kjerner. Kostnaden: høyere overhead (prosessoppstart) og data må **serialiseres** mellom prosesser (ingen delt minne som standard).

## asyncio — for høy-concurrency 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 håndterer massive mengder samtidige I/O-operasjoner på én tråd, mer effektivt enn tråder (ingen per-tråd overhead) — ideelt for servere og høy-concurrency nettverkskode.

## Beslutningsveiledningen

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

## Hvorfor det er viktig

Å velge riktig concurrency-modell er en av de mest konsekvente Python-ytelsesavgjørelsene, og å gjøre det feil (den klassiske feilen: tråder for CPU-bound arbeid, som GIL gjør ubrukelig) fører til kode som ikke skaleres.

Den veiledende logikken flyter fra GIL: **threads/asyncio for I/O-bound** (GIL frigjøres under venting — concurrency fungerer) og **multiprocessing for CPU-bound** (separate GILs for virkelig parallellisme), med asyncio foretrukket når concurrency er svært høy.

Å forstå hver modells styrker, kostnader (prosess overhead/serialisering, asyncios bibliotekskrav), og I/O-vs-CPU-beslutningen er essensielt for å skrive concurrent Python som faktisk leverer ytelse.