Kada trebate koristiti `async def` nasuprot `def` za endpoints?

Question

Accepted Answer

FastAPI podržava i `async def` i obični `def` za operacije putanje. Izbor je bitan za performanse: koristite **`async def`** kada možete `await` neblokiranje I/O, i obični **`def`** kada vaš kod poziva blokiranje (sinkrone) operacije.

## Dva oblika

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

## Kako FastAPI obrađuje svaki

```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.
```

## Pravilo odlučivanja

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

Kritično pravilo: **nikada ne stavljajte blokiranje pozive u `async def`** — to blokira event petlju i uništava konkurentnost. Ili koristite async biblioteku sa `await`, ili koristite običan `def` (koji FastAPI sigurno pokreće u thread pool).

## Zašto je to važno

Izbor između `async def` i `def` izravno utječe na performanse i konkurentnost vaše API, a pogrešan izbor je česta i ozbiljna greška.

Kljući uvid je da je **`async def` koristan samo kada `await` neblokiranje operacije** — stavljanje blokiranje poziva (kao što je sinkrona `requests` biblioteka ili driver baze podataka koji blokira) u `async def` blokira cijelu event petlju, zamrzava sve istovremene zahtjeve i poništava svrhu async.

Obrnuto, FastAPI pametno pokreće obične `def` endpoints u thread pool, tako da je sinkron/blokiranje kod bezbedan tamo.

Razumijevanje ovog pravila — koristi `async def` s pravim async bibliotekama, koristi običan `def` za blokiranje kod, i nikada nemešajte blokiranje pozive u `async def` — bitno je za pisanje performantnih FastAPI endpoints i izbjegavanje suptilne ali katastrofalne greške slučajnog serijaliziranja svih zahtjeva iza blokirane event petlje.