asyncio yaiku framework Python kanggo concurrent I/O nggunakake async/await. Iku mbukak akeh operasi I/O sacara kooperatif ing siji thread liwat event loop — efisien kanggo karya I/O-bound kanthi concurrency dhuwur (network calls, web servers) tanpa overhead saka threads.
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 yaiku coroutine; await nggantung iku ing titik I/O, nglilakokake event loop mbukak coroutines liyane samwisane — banjur nerusake manawa operasi awaited rampung.
# ❌ 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 mbukak coroutines concurrently — nalika siji nunggu I/O, liyane bisa maju. Telu nunggu 1-second saling tumpang tindih dadi ~1 secon sakabèhé. Iki nilai utamane: numpang tindihake akeh I/O waits ing siji thread.
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)
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)
Amarga iku kooperatif lan single-threaded, sembarang blocking/CPU-heavy call bisa biru kabèh coroutines. Gunakaké await-able async APIs, lan pindahake blocking/CPU work menyang executor.
✓ 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)
asyncio yaiku cara modern kanggo high-concurrency I/O ing Python, nyukupi frameworks kaya FastAPI lan nglilakokake handling sing efisien saka ribuan simultaneous connections ing siji thread — luwih ringgan tinimbang thread-per-connection.
Ngerti coroutines, await, concurrent execution kanthi gather, lan utama yaiku aturan utama (aja ngblokir event loop; pindahake CPU/blocking work) yaiku penting kanggo nulis async Python sing performan.
Ngerti kapan iku cocok (I/O-bound concurrency) lawan kapan ora (CPU-bound → multiprocessing) yaiku kunci kanggo nggunakake iku kanthi efektif.