endpoints க்கான `async def` மற்றும் `def` ஐ எப்போது பயன்படுத்த வேண்டும்?

Question

Accepted Answer

FastAPI பாதை செயல்பாடுகளுக்கு `async def` மற்றும் வழக்கமான `def` இரண்டையும் ஆதரிக்கிறது. தேர்வு செயல்திறனுக்கு முக்கியமானது: தடைபடாத I/O `await` செய்ய முடியும் போது **`async def`** ஐ பயன்படுத்தவும், மற்றும் உங்கள் குறியீடு தடைபடுத்தும் (ஒத்திசைவான) செயல்பாடுகளை அழைக்கும் போது வழக்கமான **`def`** ஐ பயன்படுத்தவும்.

## இரண்டு வடிவங்கள்

```python
@app.get("/async")
async def async_endpoint():
    data = await fetch_from_api()        # await non-blocking I/O — efficient
    return data

@app.get("/sync")
def sync_endpoint():
    data = blocking_db_call()             # ordinary blocking code
    return data
```

## FastAPI ஒவ்வொன்றையும் எவ்வாறு கையாளுகிறது

```text
async def → runs on the main event loop. Efficient ONLY if you await non-blocking calls.
            ⚠️ A BLOCKING call inside async def blocks the WHOLE event loop → kills concurrency!
def       → FastAPI runs it in a THREAD POOL, so blocking code doesn't block the event loop.
            Safe for synchronous/blocking libraries.
```

## முடிவெடுக்கும் விதி

```python
# ✅ async def — when you can await async libraries (httpx, async DB drivers)
async def get_user():
    async with httpx.AsyncClient() as c:
        return await c.get(url)

# ✅ plain def — when using SYNCHRONOUS/blocking libraries (requests, sync ORM)
def get_user():
    return requests.get(url).json()       # blocking → FastAPI runs it in a thread

# ❌ THE DANGEROUS MISTAKE — blocking call inside async def
async def bad():
    return requests.get(url).json()       # blocks the event loop! Use `def` or an async client
```

சிக்கலான விதி: **`async def` இல் எப்போதும் தடைபடுத்தும் அழைப்புகளை வைக்க வேண்டாம்** — இது event loop ஐ தடைபடுத்தி ஒத்திசைவை அழிக்கிறது. `await` உடன் async நூலகத்தைப் பயன்படுத்தவும், அல்லது வழக்கமான `def` ஐப் பயன்படுத்தவும் (FastAPI இதை thread pool இல் பாதுகாப்பாக இயக்குகிறது).

## ஏன் இது முக்கியமானது

`async def` மற்றும் `def` இடையே சரியாக தேர்வு செய்வது உங்கள் API இன் செயல்திறன் மற்றும் ஒத்திசைவை நேரடியாக பாதிக்கிறது, மற்றும் அதை தவறாகப் பெறுவது ஒரு பொதுவான, கடுமையான பிழை.

மূল்যமான நுண்ணறிவு என்னவென்றால் **`async def` தடைபடாத செயல்பாடுகளை `await` செய்யும் போது மட்டுமே பயனுள்ளது** — தடைபடுத்தும் அழைப்பை (ஒத்திசைவான `requests` நூலகம் அல்லது தடைபடுத்தும் தரவுசேகரம் இயக்கி போன்றவை) `async def` இல் வைப்பது முழு event loop ஐ தடைபடுத்துகிறது, அனைத்து ஒத்திசைவான கோரிக்கைகளையும் குறிப்பிடுகிறது மற்றும் async இன் நோக்கத்தை அழிக்கிறது.

திரும்பி, FastAPI புத்திசாலித்தன்மையுடன் வழக்கமான `def` endpoints ஐ thread pool இல் இயக்குகிறது, எனவே ஒத்திசைவான/தடைபடுத்தும் குறியீடு அங்கே பாதுகாப்பானது.

இந்த விதியைப் புரிந்துகொள்வது — உண்மையான async நூலகங்களுடன் `async def` ஐப் பயன்படுத்தவும், தடைபடுத்தும் குறியீட்டுக்கு வழக்கமான `def` ஐ பயன்படுத்தவும், மற்றும் `async def` க்குள் தடைபடுத்தும் அழைப்புகளை ஒருபோதும் கலக்க வேண்டாம் — செயல்திறன்மிக்க FastAPI endpoints ஐ எழுதுவதற்கும் தடைபடுத்தப்பட்ட event loop பின்னால் அனைத்து கோரிக்கைகளையும் தற்செயலாக தொடர்படுத்தும் நுண்ணிய ஆனால் பேரழிவு பிழையை தவிர்ப்பதற்கும் அপরிহார்யமானது.