Milloin sinun tulisi käyttää async def:ä vs def:ä päätepisteiden kanssa?

Question

Accepted Answer

FastAPI tukee sekä `async def`:ää että tavallista `def`:ää polkuoperaatioissa. Valinta vaikuttaa suorituskykyyn: käytä **`async def`**:ää kun voit `await`:ata ei-estäviä I/O-operaatioita, ja tavallista **`def`**:ää kun koodisi kutsuu estäviä (synkronisia) operaatioita.

## Kaksi muotoa

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

## Kuinka FastAPI käsittelee jokaisen

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

## Päätöksentekosääntö

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

Kritiikin sääntö: **älä koskaan laita estäviä kutsuja `async def`:ään** — se estää event loop:in ja tuhoaa samanaikaisuuden. Käytä joko async-kirjastoa `await`:lla, tai käytä tavallista `def`:ää (jonka FastAPI turvallisesti suorittaa säiealtaassa).

## Miksi se on tärkeää

Oikean valinnan tekeminen `async def`:n ja `def`:n välillä vaikuttaa suoraan API:si suorituskykyyn ja samanaikaisuuteen, ja väärä valinta on yleinen, vakava virhe.

Avainsisältö on, että **`async def` on hyödyllinen vain kun `await`:aat ei-estäviä operaatioita** — estävän kutsun (kuten synkronisen `requests`-kirjaston tai estävän tietokantaohjain) asettaminen `async def`:ään estää koko event loop:in, jäädyttää kaikki samanaikaiset pyynnöt ja tuhoaa async:in tarkoituksen.

Toisaalta FastAPI järkevästi suorittaa tavallisia `def`-päätepisteitä säiealtaassa, joten synkroninen/estävä koodi on turvallista siellä.

Tämän säännön ymmärtäminen — käytä `async def`:ää todella async-kirjastojen kanssa, käytä tavallista `def`:ää estävälle koodille, ja älä koskaan sekoita estäviä kutsuja `async def`:ään — on olennaista suorituskykyisten FastAPI-päätepisteiden kirjoittamiselle ja vakavan virheen välttämiselle, jossa vahingossa sarjallistoit kaikki pyynnöt estetyn event loop:in taakse.