async/await asyncio ile nasıl çalışır?

Question

Accepted Answer

**asyncio**, `async`/`await` kullanarak Python'un **concurrent I/O** için çerçevesidir. Bir event loop aracılığıyla **tek bir thread** üzerinde birçok I/O işlemini işbirliğine dayalı olarak çalıştırır — yüksek eşzamanlılık I/O-bağlı iş (ağ çağrıları, web sunucuları) için verimlidir ve thread'lerin overhead'i yoktur.

## Coroutine'leri tanımlama ve çalıştırma

```python
import asyncio

async def fetch_data(id):       # an async function = a coroutine
    print(f"start {id}")
    await asyncio.sleep(1)       # await a non-blocking I/O operation (yields control)
    print(f"done {id}")
    return id

asyncio.run(fetch_data(1))       # run a coroutine from sync code
```

Bir `async def` fonksiyonu bir **coroutine**'dir; `await` onu bir I/O noktasında askıya alır, event loop'un *diğer* coroutine'leri çalıştırmasına izin verir — ardından beklenen işlem tamamlandığında sürdürülür.

## Temel fayda: concurrent I/O

```python
# ❌ sequential — total time ≈ 3 seconds
async def slow():
    await fetch_data(1)   # wait 1s
    await fetch_data(2)   # then wait 1s
    await fetch_data(3)   # then wait 1s

# ✅ concurrent — total time ≈ 1 second (all run together)
async def fast():
    await asyncio.gather(fetch_data(1), fetch_data(2), fetch_data(3))
```

`asyncio.gather` coroutine'leri **eşzamanlı olarak** çalıştırır — biri I/O'yu beklerken, diğerleri ilerler. Üç 1 saniyelik bekleme ~1 saniye toplama çakışır. Bu temel değerdir: tek bir thread üzerinde birçok I/O beklemeyi çakıştırmak.

## Thread'lerden nasıl farklı

```text
Threading:  OS-managed, preemptive, real threads (GIL-limited for CPU)
asyncio:    single thread, COOPERATIVE — coroutines yield at `await` points
            → lighter weight (handle thousands of connections), no thread overhead,
              but one CPU-heavy coroutine blocks everything (no preemption)
```

## Kardinal kural: event loop'u engellemeyin

```python
async def bad():
    time.sleep(5)              # ❌ BLOCKS the whole event loop (sync sleep)
    result = heavy_compute()    # ❌ CPU work freezes all coroutines

async def good():
    await asyncio.sleep(5)      # ✅ non-blocking
    # offload CPU work to a thread/process pool
    await loop.run_in_executor(None, heavy_compute)
```

İşbirliğine dayalı ve tek-thread olduğundan, herhangi bir blocking/CPU-ağır çağrı *tüm* coroutine'leri dondurur. `await`-lanabilir async API'ları kullanın ve blocking/CPU işini bir executor'e yükleyin.

## asyncio'nun parlak olduğu yerler

```text
✓ High-concurrency I/O: web servers (FastAPI), web scraping, many API/DB calls,
  websockets, real-time apps — thousands of concurrent connections efficiently
✗ CPU-bound work — use multiprocessing instead (asyncio doesn't help)
```

## Neden önemli

asyncio, Python'da **yüksek-eşzamanlılık I/O** için modern yaklaşımdır, FastAPI gibi çerçeveleri güçlendirir ve tek bir thread üzerinde binlerce eşzamanlı bağlantıyı verimli bir şekilde işlemeyi sağlar — thread-per-connection'den çok daha hafiftir.

Coroutine'leri, `await`'i, `gather` ile concurrent yürütmeyi ve özellikle **kardinal kuralı** (event loop'u engellemeyin; CPU/blocking işini yükleyin) anlamak, performans açısından verimli async Python yazmak için çok önemlidir.

Ne zaman uygun olduğunu (I/O-bağlı eşzamanlılık) ne zaman olmadığını (CPU-bağlı → multiprocessing) bilmek, onu etkili bir şekilde kullanmanın anahtarıdır.