რა დროს უნდა გამოიყენოთ async def vs def ენდპოინტებისთვის?

Question

IT Interview Practice · Accepted Answer

FastAPI поддерживает როგორც `async def`, ასევე ჩვეულებრივ `def`-ს path operations-ებისთვის. არჩევანი მნიშვნელოვანია საიმედოობისთვის: გამოიყენეთ **`async def`** როდესაც შეგიძლიათ `await` non-blocking I/O-ს, და ჩვეულებრივი **`def`** როდესაც თქვენი კოდი იძახებს blocking (synchronous) operations-ს.

## ორი ფორმა

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

კრიტიკული წესი: **არასოდეს დადოთ blocking calls `async def`-ში** — ეს აკეთებს event loop-ს blocked და ანადგურებს concurrency-ს. ან გამოიყენეთ async library `await`-ით, ან გამოიყენეთ plain `def` (რომელიც FastAPI უსაფრთხოდ აყენებს thread pool-ში).

## რატომ აქვს მნიშვნელობა

სწორი არჩევანი `async def` და `def`-ს შორის პირდაპირ გავლენას ახდენს თქვენი API-ს საიმედოობაზე და concurrency-ზე, და ამის არასწორად გაკეთება არის საერთო, სერიოზული შეცდომა.

მთავარი insight არის, რომ **`async def` სასარგებლოა მხოლოდ მაშინ, როდესაც `await` non-blocking operations-ს** — blocking call-ის დადება (როგორიცაა synchronous `requests` library ან blocking database driver) `async def`-ში აკეთებს entire event loop-ს blocked, გაყინებს ყველა concurrent requests-ს და ანადგურებს async-ის მიზანს.

საპირისპიროდ, FastAPI ჭკვიანურად აქენებს plain `def` endpoints-ებს thread pool-ში, ამიტომ synchronous/blocking კოდი უსაფრთხოა იქ.

ამ წესის გაგება — `async def` გამოიყენეთ truly async libraries-თან, plain `def`-ს გამოიყენეთ blocking კოდისთვის, და არასოდეს აურიოთ blocking calls `async def`-ში — აუცილებელია performant FastAPI endpoints-ების დაწერისთვის და subtle მაგრამ კატასტროფული შეცდომის თავიდან აცილებისთვის, როდესაც თქვენ არაკერძოთ თავისუფლად serialized ყველა requests თქვენი blocked event loop-ის უკან.

ორი ფორმა

როგორ FastAPI აკეთებს თითოეულს

გადაწყვეტილების წესი

რატომ აქვს მნიშვნელობა

დაკავშირებული კითხვები