ਤੁਹਾਨੂੰ 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` ਨਾਲ ਇੱਕ ਐਸਿਕ ਲਾਈਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਾਂ ਇੱਕ ਸਾਦੀ `def` ਦੀ ਵਰਤੋਂ ਕਰੋ (ਜਿਸ ਨੂੰ FastAPI ਸੁਰੱਖਿਤ ਰੂਪ ਵਿੱਚ ਇੱਕ ਥ੍ਰੈਡ ਪੂਲ ਵਿੱਚ ਚਲਾਉਂਦਾ ਹੈ)।

## ਇਸ ਦा ਮਾਇਨਾ ਕਿਉਂ ਹੈ

`async def` ਅਤੇ `def` ਵਿਚਕਾਰ ਸਹੀ ਚੁਣਾਵ ਤੁਹਾਡੇ API ਦੀ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਸਮਕਾਲੀਨਤਾ ਨੂੰ ਸਿੱਧਾ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਗਲਤ ਕਰਨਾ ਇੱਕ ਆਮ, ਗੰਭੀਰ ਗਲਤੀ ਹੈ।

ਮੁੱਖ ਸਮਝ ਇਹ ਹੈ ਕਿ **`async def` ਸਿਰਫ ਲਾਭਦਾਇਕ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਗੈਰ-ਬਲਾਕਿੰਗ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ `await` ਕਰਦੇ ਹੋ** — ਇੱਕ ਬਲਾਕਿੰਗ ਕਾਲ (ਜਿਵੇਂ ਸਿੰਕਰੋਨਸ `requests` ਲਾਈਬ੍ਰੇਰੀ ਜਾਂ ਬਲਾਕਿੰਗ ਡਾਟਾਬੇਸ ਡ੍ਰਾਈਵਰ) ਨੂੰ `async def` ਵਿੱਚ ਰੱਖਣਾ ਪੂਰੇ ਇਵੈਂਟ ਲੂਪ ਨੂੰ ਬਲਾਕ ਕਰਦਾ ਹੈ, ਸਾਰੀਆਂ ਸਮਕਾਲੀ ਬੇਨਤੀਆਂ ਨੂੰ ਫ੍ਰੀਜ ਕਰਦਾ ਹੈ ਅਤੇ async ਦੇ ਉਦੇਸ਼ ਨੂੰ ਨੁਕਸਾਨ ਪਹੁੰਚਾਉਂਦਾ ਹੈ।

ਇਸ ਦੇ ਉਲਟ, FastAPI ਕੁਸ਼ਲ ਰੂਪ ਨਾਲ ਸਾਦੀ `def` endpoints ਨੂੰ ਇੱਕ ਥ੍ਰੈਡ ਪੂਲ ਵਿੱਚ ਚਲਾਉਂਦਾ ਹੈ, ਇਸ ਲਈ ਸਿੰਕਰੋਨਸ/ਬਲਾਕਿੰਗ ਕੋਡ ਉਥੇ ਸੁਰੱਖਿਤ ਹੈ।

ਇਸ ਨਿਯਮ ਨੂੰ ਸਮਝਣਾ — `async def` ਨੂੰ ਸਚਮੁੱਚ ਐਸਿਕ ਲਾਈਬ੍ਰੇਰੀਆਂ ਨਾਲ ਵਰਤੋ, ਬਲਾਕਿੰਗ ਕੋਡ ਲਈ ਸਾਦੀ `def` ਵਰਤੋ, ਅਤੇ ਕਦੀ ਵੀ ਬਲਾਕਿੰਗ ਕਾਲਾਂ ਨੂੰ `async def` ਵਿੱਚ ਮਿਸ਼ਰਿਤ ਨਾ ਕਰੋ — ਪ੍ਰਦਰਸ਼ਨਸ਼ੀਲ FastAPI endpoints ਲਿਖਣ ਅਤੇ ਸਭ ਬੇਨਤੀਆਂ ਨੂੰ ਇੱਕ ਬਲਾਕ ਕੀਤੇ ਇਵੈਂਟ ਲੂਪ ਦੇ ਪਿੱਛੇ ਗਲਤੀ ਨਾਲ ਸੀਰੀਅਲ ਕਰਨ ਦੀ ਸੂਖਮ ਪਰ ਵਿਨਾਸ਼ਕਾਰੀ ਗਲਤੀ ਤੋਂ ਬਚਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।