async/await กับ asyncio ทำงานอย่างไร?

Question

Accepted Answer

**asyncio** เป็นเฟรมเวิร์กของ Python สำหรับ **concurrent I/O** โดยใช้ `async`/`await` มันรันการดำเนินการ I/O หลายรายการร่วมกันบน **single thread** ผ่าน event loop — มีประสิทธิภาพสำหรับการทำงาน I/O-bound ที่มี concurrency สูง (เรียก network, web servers) โดยไม่มีค่าใช้จ่ายของ threads

## การกำหนด และการรัน coroutines

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

ฟังก์ชัน `async def` เป็น **coroutine**; `await` หยุดมันที่จุด I/O ทำให้ event loop รัน *coroutines อื่น* ในระหว่างนั้น — จากนั้นก็ดำเนินต่อเมื่อการดำเนินการที่รอเสร็จสิ้น

## ประโยชน์หลัก: concurrent I/O

```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` รัน coroutines **concurrently** — ขณะที่อันหนึ่งรอ I/O อันอื่นก็ดำเนินต่อ การรอสามครั้ง 1 วินาที ซ้อนกันเป็น ~1 วินาที รวม นี่คือมูลค่าหลัก: การซ้อนการรอ I/O หลายรายการบน thread เดียว

## วิธีที่แตกต่างจาก threads

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

## กฎหลัก: อย่าปิดกั้น 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)
```

เพราะว่ามันเป็นแบบสหกรรมการ และ single-threaded การเรียก blocking/CPU-heavy ใดๆ จะทำให้ *coroutines ทั้งหมด* หยุดชั่วคราว ใช้ `await`-able async APIs และย้ายงาน blocking/CPU ไปยัง executor

## ที่ที่ asyncio ส่องแสง

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

## ทำไมจึงสำคัญ

asyncio เป็นวิธีสมัยใหม่สำหรับ **high-concurrency I/O** ใน Python ขับเคลื่อน frameworks เช่น FastAPI และเปิดใจให้สามารถจัดการการเชื่อมต่อพร้อมกันหลายพันรายการบน thread เดียว — เบากว่า thread-per-connection มาก

การเข้าใจ coroutines, `await`, concurrent execution ด้วย `gather` และโดยเฉพาะ **กฎหลัก** (อย่าปิดกั้น event loop; ย้ายงาน CPU/blocking) เป็นสิ่งจำเป็นสำหรับการเขียน async Python ที่มีประสิทธิภาพ

การรู้เมื่อใดที่มันเหมาะสม (I/O-bound concurrency) เทียบกับเมื่อไม่เหมาะ (CPU-bound → multiprocessing) เป็นกุญแจสำคัญในการใช้มันอย่างมีประสิทธิภาพ