Når skal du bruke async def versus def for endepunkter?

Question

IT Interview Practice · Accepted Answer

FastAPI støtter både `async def` og regular `def` for stieoperasjoner. Valget betyr noe for ytelsen: bruk **`async def`** når du kan `await` ikke-blokkerende I/O, og regular **`def`** når koden din kaller blokkerende (synkrone) operasjoner.

## De to formene

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

## Hvordan FastAPI håndterer hver form

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

## Beslutningsregelen

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

Den kritiske regelen: **putt aldri blokkerende anrop i `async def`** — det blokkerer event-løkken og ødelegger samtidighet. Enten bruk et async-bibliotek med `await`, eller bruk en plain `def` (som FastAPI trygt kjører i en thread pool).

## Hvorfor det betyr noe

Å velge riktig mellom `async def` og `def` påvirker direkte ytelsen og samtidigheten til API-en din, og å gjøre det galt er en vanlig, alvorlig feil.

Kjerneinnsikten er at **`async def` bare er fordelaktig når du `await` ikke-blokkerende operasjoner** — å plassere et blokkerende anrop (som det synkrone `requests`-biblioteket eller en blokkerende databasedriver) inne i en `async def` blokkerer hele event-løkken, fryser alle samtidige forespørsler og ødelegger formålet med async.

Omvendt kjører FastAPI smart vanlige `def`-endepunkter i en thread pool, så synkron/blokkerende kode er sikker der.

Å forstå denne regelen — bruk `async def` med virkelig async-biblioteker, bruk plain `def` for blokkerende kode, og bland aldri blokkerende anrop inn i `async def` — er avgjørende for å skrive performante FastAPI-endepunkter og for å unngå den subtile men ødeleggende feilen ved å utilsiktet serialisere alle forespørsler bak en blokkert event-løkke.

De to formene

Hvordan FastAPI håndterer hver form

Beslutningsregelen

Hvorfor det betyr noe

Relaterte spørsmål