Πώς λειτουργεί το async/await με asyncio;

Question

IT Interview Practice · Accepted Answer

**asyncio** είναι το framework του Python για **concurrent I/O** χρησιμοποιώντας `async`/`await`. Εκτελεί πολλές I/O λειτουργίες συνεργατικά σε ένα **ενιαίο thread** μέσω ενός event loop — αποτελεσματικό για εργασίες I/O-bound υψηλής ταυτοχρονίας (κλήσεις δικτύου, διακομιστές ιστού) χωρίς το κόστος των threads.

## Ορισμός και εκτέλεση coroutines

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

Μια συνάρτηση `async def` είναι μια **coroutine**; το `await` την αναστέλλει σε ένα σημείο I/O, επιτρέποντας στο event loop να εκτελέσει *άλλες* coroutines — και στη συνέχεια συνεχίζεται όταν ολοκληρωθεί η αναμενόμενη λειτουργία.

## Το κύριο όφελος: ταυτόχρονο 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` εκτελεί coroutines **ταυτόχρονα** — ενώ ένα περιμένει I/O, τα άλλα προχωρούν. Τρεις αναμονές 1 δευτερολέπτου επικαλύπτονται σε ~1 δευτερόλεπτο συνολικά. Αυτή είναι η βασική αξία: επικάλυψη πολλών αναμονών I/O σε ένα thread.

## Πώς διαφέρει από τα threads

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

## Ο καρδινάλιος κανόνας: μην φραγείτε το event loop

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

Επειδή είναι συνεργατικό και single-threaded, οποιαδήποτε κλήση αποκλεισμού/CPU-heavy παγώνει *όλες* τις coroutines. Χρησιμοποιήστε `await`-able async APIs και μεταφέρετε εργασίες αποκλεισμού/CPU σε ένα executor.

## Όπου λάμπει το asyncio

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

## Γιατί είναι σημαντικό

To asyncio είναι η σύγχρονη προσέγγιση για **high-concurrency I/O** στο Python, τροφοδοτεί frameworks όπως το FastAPI και επιτρέπει την αποτελεσματική διαχείριση χιλιάδων ταυτόχρονων συνδέσεων σε ένα ενιαίο thread — πολύ ελαφρύτερο από το thread-per-connection.

Η κατανόηση των coroutines, `await`, ταυτόχρονης εκτέλεσης με `gather` και ιδιαίτερα του **καρδιναλίου κανόνα** (μη φράξετε ποτέ το event loop· μεταφέρετε εργασίες CPU/αποκλεισμού) είναι απαραίτητη για τη σύνταξη αποδοτικού async Python.

Το να γνωρίζετε πότε ταιριάζει (I/O-bound ταυτοχρονία) έναντι πότε δεν ταιριάζει (CPU-bound → multiprocessing) είναι το κλειδί για τη δραστική χρήση του.

Ορισμός και εκτέλεση coroutines

Το κύριο όφελος: ταυτόχρονο I/O

Πώς διαφέρει από τα threads

Ο καρδινάλιος κανόνας: μην φραγείτε το event loop

Όπου λάμπει το asyncio

Γιατί είναι σημαντικό

Σχετικές ερωτήσεις