Bagaimana async/await dengan asyncio berfungsi?

Question

Accepted Answer

**asyncio** ialah rangka kerja Python untuk **I/O serentak** menggunakan `async`/`await`. Ia menjalankan banyak operasi I/O secara koperatif pada **satu thread tunggal** melalui event loop — cekap untuk kerja terikat-I/O berkonkurensi tinggi (panggilan rangkaian, pelayan web) tanpa overhead thread.

## Mentakrif dan menjalankan coroutine

```python
import asyncio

async def fetch_data(id):       # an async function = a coroutine
    print(f"start {id}")
    await asyncio.sleep(1)       # await a non-blocking I/O operation (yields control)
    print(f"done {id}")
    return id

asyncio.run(fetch_data(1))       # run a coroutine from sync code
```

Fungsi `async def` ialah sebuah **coroutine**; `await` menggantungnya pada satu titik I/O, membolehkan event loop menjalankan coroutine *lain* sementara itu — kemudian menyambungnya semula apabila operasi yang ditunggu selesai.

## Manfaat utama: I/O serentak

```python
# ❌ sequential — total time ≈ 3 seconds
async def slow():
    await fetch_data(1)   # wait 1s
    await fetch_data(2)   # then wait 1s
    await fetch_data(3)   # then wait 1s

# ✅ concurrent — total time ≈ 1 second (all run together)
async def fast():
    await asyncio.gather(fetch_data(1), fetch_data(2), fetch_data(3))
```

`asyncio.gather` menjalankan coroutine **secara serentak** — semasa satu menunggu I/O, yang lain meneruskan. Tiga tempoh menunggu 1 saat bertindih menjadi ~1 saat secara keseluruhan. Inilah nilai terasnya: menindih banyak tempoh menunggu I/O pada satu thread.

## Bagaimana ia berbeza daripada thread

```text
Threading:  OS-managed, preemptive, real threads (GIL-limited for CPU)
asyncio:    single thread, COOPERATIVE — coroutines yield at `await` points
            → lighter weight (handle thousands of connections), no thread overhead,
              but one CPU-heavy coroutine blocks everything (no preemption)
```

## Peraturan utama: jangan sekat event loop

```python
async def bad():
    time.sleep(5)              # ❌ BLOCKS the whole event loop (sync sleep)
    result = heavy_compute()    # ❌ CPU work freezes all coroutines

async def good():
    await asyncio.sleep(5)      # ✅ non-blocking
    # offload CPU work to a thread/process pool
    await loop.run_in_executor(None, heavy_compute)
```

Kerana ia bersifat koperatif dan satu-thread, sebarang panggilan yang menyekat/berat-CPU akan membekukan *semua* coroutine. Gunakan API async yang boleh di-`await`, dan pindahkan kerja yang menyekat/berat-CPU ke executor.

## Di mana asyncio menyerlah

```text
✓ High-concurrency I/O: web servers (FastAPI), web scraping, many API/DB calls,
  websockets, real-time apps — thousands of concurrent connections efficiently
✗ CPU-bound work — use multiprocessing instead (asyncio doesn't help)
```

## Mengapa ia penting

asyncio ialah pendekatan moden untuk **I/O berkonkurensi tinggi** dalam Python, menggerakkan rangka kerja seperti FastAPI dan membolehkan pengendalian cekap beribu-ribu sambungan serentak pada satu thread tunggal — jauh lebih ringan daripada thread-setiap-sambungan.

Memahami coroutine, `await`, pelaksanaan serentak dengan `gather`, dan terutamanya **peraturan utama** (jangan sekali-kali menyekat event loop; pindahkan kerja CPU/menyekat) adalah penting untuk menulis Python async yang berprestasi.

Mengetahui bila ia sesuai (konkurensi terikat-I/O) berbanding bila ia tidak sesuai (terikat-CPU → multiprocessing) ialah kunci untuk menggunakannya secara berkesan.