การรองรับ async ใน Django สมัยใหม่ทำงานอย่างไร?

Question

Accepted Answer

Django สมัยใหม่ (3.1+) รองรับ **async view** โดยใช้ `async`/`await` ของ Python ซึ่งช่วยให้จัดการการทำงานพร้อมกันที่ **I/O-bound** ได้อย่างมีประสิทธิภาพ (การเรียก external API, การเข้าถึงฐานข้อมูลแบบ async) โดยไม่บล็อก สิ่งนี้เสริมโมเดล synchronous แบบดั้งเดิมของ Django สำหรับกรณีการใช้งานเฉพาะ

## Async view

```python
# a synchronous view (the traditional default)
def sync_view(request):
    data = requests.get("https://api.example.com").json()   # BLOCKS the worker
    return JsonResponse(data)

# an async view — can await I/O without blocking
import httpx
async def async_view(request):
    async with httpx.AsyncClient() as client:
        response = await client.get("https://api.example.com")   # non-blocking await
    return JsonResponse(response.json())
```

view แบบ `async def` สามารถ `await` การทำงาน I/O ได้ ทำให้เซิร์ฟเวอร์จัดการ request อื่นได้ในระหว่างที่รอ — มีประสิทธิภาพสำหรับ view ที่เรียก external ที่ช้า

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

```python
import asyncio

async def dashboard(request):
    # run multiple slow API calls CONCURRENTLY instead of sequentially
    users, orders, stats = await asyncio.gather(
        fetch_users(),
        fetch_orders(),
        fetch_stats(),
    )
    # 3 calls taking 1s each → ~1s total (concurrent), not 3s (sequential)
    return JsonResponse({"users": users, "orders": orders, "stats": stats})
```

ข้อได้เปรียบหลัก: การ await การทำงาน I/O อิสระหลายตัว **พร้อมกัน** (ด้วย `asyncio.gather`) — ทำให้เวลารอของแต่ละตัวซ้อนทับกัน ได้ความเร็วเพิ่มขึ้นมากเมื่อ view รวบรวมข้อมูลจากหลายแหล่งที่ช้า

## Async ORM (Django สมัยใหม่)

```python
# async query methods (Django 4.1+)
async def get_articles(request):
    articles = [a async for a in Article.objects.all()]    # async iteration
    article = await Article.objects.aget(pk=1)              # async get
    await Article.objects.acreate(title="New")             # async create
    return JsonResponse({...})
```

ปัจจุบัน Django มีเมธอด ORM แบบ async (`aget`, `acreate`, `async for`) เพื่อให้คุณเข้าถึงฐานข้อมูลภายใน async view ได้โดยไม่บล็อก

## ข้อควรระวังสำคัญและเมื่อใดควรใช้ async

```text
✓ USE async for: I/O-bound views with concurrent external calls, slow APIs,
  websockets/streaming, high-concurrency I/O workloads
✗ DON'T expect async to speed up CPU-bound work (it doesn't — that's not the point)
✗ Don't call SYNCHRONOUS blocking code directly in async views (blocks the event loop)
  → wrap it with sync_to_async; use async-compatible libraries (httpx, async ORM)
✗ Much of the Django ecosystem is still sync — mixing requires care (async_to_sync / sync_to_async)
Deployment: needs an ASGI server (uvicorn, daphne), not just WSGI
```

## การเชื่อมระหว่าง sync และ async

```python
from asgiref.sync import sync_to_async, async_to_sync
result = await sync_to_async(blocking_function)()   # run sync code from async safely
```

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

การรองรับ async เป็นความสามารถสำคัญของ Django สมัยใหม่ที่ควรเข้าใจ แม้ว่าการนำไปใช้จะมีความเฉพาะเจาะจง — มันให้ประโยชน์จริงสำหรับ **workload ที่ I/O-bound และมี concurrency สูง** แต่ไม่ใช่คำตอบสากล

คุณค่าหลักคือการเปิดทางให้ทำ concurrent I/O ได้อย่างมีประสิทธิภาพ: async view สามารถ `await` การทำงานที่ช้า (การเรียก external API, query ฐานข้อมูลแบบ async) ได้โดยไม่บล็อก worker และที่สำคัญคือสามารถรันการทำงาน I/O อิสระหลายตัว **พร้อมกัน** (ผ่าน `asyncio.gather`) ทำให้เวลารอซ้อนทับกัน — ได้ความเร็วเพิ่มขึ้นมากสำหรับ view ที่รวบรวมข้อมูลจากหลายแหล่ง external ที่ช้า หรือสำหรับสถานการณ์ I/O ที่มี concurrency สูงอย่าง websocket และ streaming

การเข้าใจว่าเมื่อใด async ช่วยได้ (concurrency แบบ I/O-bound) เทียบกับเมื่อใดที่ไม่ช่วย (มันไม่มีประโยชน์สำหรับงาน CPU-bound) เป็นสิ่งจำเป็นต่อการใช้มันอย่างเหมาะสมแทนที่จะนำไปใช้ทุกที่แบบลอกตาม

สิ่งที่สำคัญพอ ๆ กันคือ **ข้อควรระวัง** ที่ทำให้ async ยุ่งยากใน Django: คุณต้องใช้ไลบรารีที่เข้ากันได้กับ async (httpx แทน requests, เมธอด ORM แบบ async อย่าง `aget`/`acreate`) และหลีกเลี่ยงการเรียกโค้ด synchronous ที่บล็อกโดยตรงใน async view (ซึ่งบล็อก event loop ทำให้เสียจุดประสงค์) — ต้องใช้การเชื่อม `sync_to_async`/`async_to_sync`, การจัดการอย่างระมัดระวังเนื่องจากระบบนิเวศของ Django ส่วนใหญ่ยังคงเป็น synchronous และต้องมี ASGI server สำหรับการ deploy

การรู้ว่า async view มีอยู่, กรณีการใช้งานจริงของมัน (concurrent I/O, ฟีเจอร์ real-time), async ORM และข้อควรระวังสำคัญ สะท้อนความตระหนักถึงวิวัฒนาการของ Django สมัยใหม่และวิจารณญาณในการนำ async ไปใช้ในที่ที่มันช่วยได้จริง

แม้จะไม่จำเป็นสำหรับทุกแอปพลิเคชัน (โมเดล synchronous ของ Django ยังคงเหมาะสมอย่างยิ่งสำหรับส่วนใหญ่) แต่ async มีความเกี่ยวข้องมากขึ้นเรื่อย ๆ สำหรับแอปพลิเคชันที่ I/O หนัก, concurrency สูง และ real-time ทำให้มันเป็นความรู้ระดับ senior ที่มีค่าสำหรับการเข้าใจความสามารถปัจจุบันของ Django และการเลือกแนวทาง concurrency ที่ถูกต้องสำหรับ workload ที่กำหนด