Kapan Anda memilih threading, multiprocessing, atau asyncio?

Question

Accepted Answer

Python menawarkan tiga model konkurensi, dan memilih dengan tepat terutama bergantung pada apakah pekerjaan Anda **I/O-bound** atau **CPU-bound** — keputusan yang sangat dipengaruhi oleh GIL (yang mencegah thread menjalankan kode Python secara paralel).

## Tiga model

```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 — untuk konkurensi I/O-bound

```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 berfungsi dengan baik untuk tugas I/O-bound (jaringan, file, DB) karena GIL dilepaskan saat menunggu — penunggu ganda berjalan secara bersamaan. Mereka **tidak pernah** mempercepat pekerjaan CPU-bound.

## multiprocessing — untuk paralelisme CPU-bound

```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 pekerjaan yang berat CPU (pemrosesan gambar, matematika, pemrosesan data), proses terpisah memotong GIL tunggal dan berjalan benar-benar paralel di beberapa inti. Biayanya: overhead yang lebih tinggi (startup proses) dan data harus **diserialisasi** antar proses (tidak ada memori bersama secara default).

## asyncio — untuk I/O konkurensi tinggi

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

asyncio menangani sejumlah besar operasi I/O bersamaan pada satu thread, lebih efisien daripada thread (tidak ada overhead per-thread) — ideal untuk server dan kode jaringan konkurensi tinggi.

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

## Mengapa ini penting

Memilih model konkurensi yang tepat adalah salah satu keputusan kinerja Python yang paling signifikan, dan memilih dengan salah (kesalahan klasik: thread untuk pekerjaan CPU-bound, yang membuat GIL tidak berguna) menyebabkan kode yang tidak dapat diskalakan.

Logika panduan mengalir dari GIL: **thread/asyncio untuk I/O-bound** (GIL dilepaskan saat menunggu — konkurensi berfungsi) dan **multiprocessing untuk CPU-bound** (GIL terpisah untuk paralelisme nyata), dengan asyncio lebih disukai ketika konkurensi sangat tinggi.

Memahami kekuatan setiap model, biaya (overhead proses/serialisasi, persyaratan perpustakaan asyncio), dan keputusan I/O-vs-CPU sangat penting untuk menulis Python bersamaan yang benar-benar memberikan kinerja.