Kapan sampeyan milih threading, multiprocessing, utawa asyncio?

Question

Accepted Answer

Python ngandhani telung model concurrency, lan milih kanthi pas gumantung utamane saka manawa karya sampeyan iku **I/O-bound** utawa **CPU-bound** — keputusan sing waé dipengaruhi dening GIL (sing nyegah thread supaya ora bisa nglumpukake Python code kanthi paralel).

## Telu model kasebut

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

Thread bisa merga kanggo tugas I/O-bound (network, file, DB) amarga GIL dibukak nalika ngenteni — sawetarane ngenteni bisa lumaku bebarengan. Nanging ora bisa nyepetake karya CPU-bound.

## multiprocessing — kanggo CPU-bound parallelism

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

Untuk karya sing pait CPU (image processing, math, data crunching), proses kapisah bisa nglumpukake GIL tunggal lan nglumpuk kanthi nyata ing sawetara core. Biayane: overhead sing luwih dhuwur (proses startup) lan data kudu **serialized** ing antarane proses (ora ana shared memory kanthi default).

## asyncio — kanggo I/O concurrency sing dhuwur

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

asyncio bisa nangani jumlah gede operasi I/O concurrent ing siji thread, luwih efisien tinimbang thread (ora ana per-thread overhead) — cocok kanggo server lan network code sing concurrency dhuwur.

## Pandoman keputusan

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

## Kenapa iku penting

Milih model concurrency sing tepat minangka salah sawijining keputusan Python performance sing paling penting, lan yen salah (kesalahan klasik: thread kanggo karya CPU-bound, sing GIL dadikan ora mudhun) bakal nyebabake code sing ora bisa berkembang.

Logika panutup mula saka GIL: **thread/asyncio kanggo I/O-bound** (GIL dibukak nalika ngenteni — concurrency bisa merga) lan **multiprocessing kanggo CPU-bound** (GIL kapisah kanggo parallelism nyata), lan asyncio luwih dipilih nalika concurrency kurang tinggi.

Nang ngerti kekuwatan saben model, biaya (process overhead/serialization, persyaratan library asyncio), lan keputusan I/O-vs-CPU iku penting kanggo nulis concurrent Python sing bener-bener ngandel performance.