நவீன Django-ல் async ஆதரவு எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

நவீன Django (3.1+) Python-ன் `async`/`await` ஐப் பயன்படுத்தி **asynchronous views** ஆதரிக்கிறது, இது **I/O-bound** சமகாலத்தில் செயல்படும் செயல்பாடுகளை (வெளிப்புற API அழைப்புகள், async database அணுக்கம்) தடையின்றி திறமையாக கையாள அனுமதிக்கிறது. இது குறிப்பிட்ட பயன்பாட்டு நிகழ்வுகளுக்கான Django-ன் பாரம்பரிய synchronous மாதிரியை நிரப்புகிறது.

## Async views

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

`async def` view I/O செயல்பாடுகளை `await` செய்யலாம், கொண்டிருக்கும் போது சர்வரை மற்ற வேண்டுகோள்களைக் கையாள அனுமதிக்கிறது — மெதுவான வெளிப்புற அழைப்புகளைச் செய்யும் views-க்கு திறமையாக உள்ளது.

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

முக்கிய நன்மை: பல சுயாதீன I/O செயல்பாடுகளை **சமகாலத்தில்** (சமகாலத்தில் பல 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 இப்போது async ORM முறைகளை வழங்குகிறது (`aget`, `acreate`, `async for`) இதனால் async views-ல் தடையின்றி database அணுக்கத்தைச் செய்யலாம்.

## முக்கியமான எச்சரிக்கைகள் மற்றும் 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 vs 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-ன் குறிப்பிடத்தக்க நவீன திறமை மற்றும் புரிந்துகொள்ள மதிப்பிடத்தக்கது, இருப்பினும் அதன் பொருந்தप்பு குறிப்பிட்டது — இது **I/O-bound, உயர் concurrent workloads**-க்கு உண்மையான நன்மைகளை வழங்குகிறது அதேசமயம் பொதுவான தீர்வாக இல்லை.

মुख्य மূल்य திறமையான concurrent I/O ஐ செயல்படுத்துவது: async views மெதுவான செயல்பாடுகளை `await` செய்யலாம் (வெளிப்புற API அழைப்புகள், async database வினவல்கள்) தடையின்றி, மிக முக்கியமாக பல சுயாதீன I/O செயல்பாடுகளை **சமகாலத்தில்** (சமகாலத்தில் `asyncio.gather` மூலம்) இயக்கலாம், அவற்றின் நிற்க நேரத்தை ஒன்றுசேர்த்து — பல மெதுவான வெளிப்புற மூலங்களிலிருந்து தரவைச் சேகரிக்கும் views-ற்கு அல்லது websockets மற்றும் streaming போன்ற உயர்-concurrent I/O சூழ்நிலைகளுக்கு பெரிய வேக மேம்பாட்டு.

Async எப்போது உதவுகிறது (I/O-bound concurrency) எதிராக எப்போது இல்லை (CPU-bound பணிக்கு இது நன்மை வழங்காது) என்பதைப் புரிந்துகொள்வது அதைப் பொருத்தமாக பயன்படுத்துவதற்கு அத்யावசியம் சகல இடத்திலும் நகலெடுக்கும் பதிலாக.

சमანViewName முக்கியமாக **எச்சரிக்கைகள்** Django-ல் async என்பது தந்திரமாக்குகிறது: async-compatible libraries ஐ பயன்படுத்த வேண்டும் (httpx requests பதிலாக, async ORM முறைகள் `aget`/`acreate` போன்றவை) மற்றும் synchronous blocking குறியீட்டை நேரடியாக async views-ல் அழைக்க வேண்டாம் (இது event loop-ஐ தடுக்கிறது, நோக்கத்தை தோல்வியடையச் செய்கிறது) — `sync_to_async`/`async_to_sync` பாலம் அமைத்தல், கவனமுடன் கையாளுதல் Django ecosystem பெரும்பாலும் synchronous ஆக உள்ளதன் காரணமாக, மற்றும் deployment-க்கு ASGI சர்வரைத் தேவை.

Async views உள்ளன, அவற்றின் உண்மையான பயன்பாட்டு நிகழ்வுகள் (concurrent I/O, நிஜ-நேர பண்புகள்), async ORM, மற்றும் முக்கியமான கெடுபிடிகள் ஆகியவற்றை அறிந்திருப்பது Django-ன் வளர்ச்சியின் சமகாலத்தை எதிரொளிக்கிறது மற்றும் async உண்மையாக உதவும் இடத்தில் பயன்படுத்த தீர்ப்பு.

প্রতিটি பயன்பாட்டுக்கு தேவை இல்லை (Django-ன் synchronous மாதிரி பெரும்பாலான பயன்பாட்டுக்கு மிகவும் பொருத்தமாக உள்ளது), async I/O-heavy, உயர்-concurrent, மற்றும் நிஜ-நேர பயன்பாட்டுக்கு점점 பொருந்தக்கூடியதாக உள்ளது, இது Django-ன் தற்போதைய திறமைகளைப் புரிந்துகொள்வதற்கும் கொடுக்கப்பட்ட workload-க்கு சரியான concurrency அணுக்கத்தைத் தேர்வு செய்வதற்கும் மதிப்பிடத்தக்க senior-level அறிவாக்கம்.