તમે endpoints માટે `async def` વિરુદ્ધ `def` ક્યારે વાપરવું જોઈએ?

Question

Accepted Answer

FastAPI `async def` અને નિયમિત `def` બંનેને પાથ ક્રિયાઓ માટે સમર્થન આપે છે. પ્રદર્શન માટે આ પસંદગી મહત્વપૂર્ણ છે: **`async def`** વાપરો જ્યારે તમે બિન-અવરોધક I/O ને `await` કરી શકો, અને નિયમિત **`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` માં ક્યારેય અવરોધક કોલ્સ મૂકશો નહીં** — તે ઇવેન્ટ લૂપને અવરોધે છે અને સમવર્તિતાને નષ્ટ કરે છે. `await` સાથે async લાઇબ્રેરી વાપરો, અથવા સાદું `def` વાપરો (જે FastAPI થ્રેડ પૂલમાં સુરક્ષિત રીતે ચલાવે છે).

## શા માટે તે મહત્વપૂર્ણ છે

`async def` અને `def` વચ્ચે સાચો પસંદ કરવો તમારા API ના કામગીરી અને સમવર્તિતાને સીધો અસર કરે છે, અને તે ખોટું કરવું એક સામાન્ય, ગંભીર ભૂલ છે.

મુખ્ય સમજ એ છે કે **`async def` તોજ ફાયદાજનક છે જ્યારે તમે બિન-અવરોધક ક્રિયાઓને `await` કરો** — અવરોધક કોલ (જેમ કે સમન્વયી `requests` લાઇબ્રેરી અથવા અવરોધક ડેટાબેસ ડ્રાઇવર) ને `async def` માં મૂકવું આખો ઇવેન્ટ લૂપને અવરોધે છે, બધા સમવર્તી વિનંતીઓને જમા કરે છે અને async ના હેતુને નષ્ટ કરે છે.

ઉલટો, FastAPI સમજદારીપૂર્વક સાદું `def` endpoints ને થ્રેડ પૂલમાં ચલાવે છે, તેથી સમન્વયી/અવરોધક કોડ ત્યાં સુરક્ષિત છે.

આ નિયમને સમજવું — સાચા async લાઇબ્રેરી સાથે `async def` વાપરો, અવરોધક કોડ માટે સાદું `def` વાપરો, અને `async def` માં ક્યારેય અવરોધક કોલ્સ મિશ્રણ કરશો નહીં — તે કાર્યક્ષમ FastAPI endpoints લખવા અને અવરોધક ઇવેન્ટ લૂપ પાછળ આકસ્મિક રીતે બધી વિનંતીઓને શ્રેણીબદ્ધ કરવાની સૂક્ષ્મ પણ વિનાશક ભૂલ ટાળવા માટે આવશ્યક છે.