asyncio의 async/await는 어떻게 동작하나요?

Question

Accepted Answer

**asyncio**는 `async`/`await`를 사용하는 Python의 **동시 I/O** 프레임워크입니다. 이벤트 루프를 통해 **단일 스레드**에서 많은 I/O 연산을 협력적으로 실행합니다 — 스레드의 오버헤드 없이 고동시성 I/O 바운드 작업(네트워크 호출, 웹 서버)에 효율적입니다.

## 코루틴 정의하고 실행하기

```python
import asyncio

async def fetch_data(id):       # async 함수 = 코루틴
    print(f"start {id}")
    await asyncio.sleep(1)       # 논블로킹 I/O 연산을 await (제어권을 양보)
    print(f"done {id}")
    return id

asyncio.run(fetch_data(1))       # 동기 코드에서 코루틴을 실행
```

`async def` 함수는 **코루틴**입니다. `await`는 I/O 지점에서 코루틴을 일시 정지시켜, 그동안 이벤트 루프가 *다른* 코루틴을 실행하게 합니다 — 그런 다음 await된 연산이 완료되면 재개합니다.

## 핵심 이점: 동시 I/O

```python
# ❌ 순차적 — 총 시간 ≈ 3초
async def slow():
    await fetch_data(1)   # 1초 대기
    await fetch_data(2)   # 그다음 1초 대기
    await fetch_data(3)   # 그다음 1초 대기

# ✅ 동시 — 총 시간 ≈ 1초 (모두 함께 실행)
async def fast():
    await asyncio.gather(fetch_data(1), fetch_data(2), fetch_data(3))
```

`asyncio.gather`는 코루틴을 **동시에** 실행합니다 — 하나가 I/O를 await하는 동안 다른 것들이 진행됩니다. 세 개의 1초 대기가 ~1초로 겹쳐집니다. 이것이 핵심 가치입니다: 한 스레드에서 많은 I/O 대기를 겹치는 것.

## 스레드와 어떻게 다른가

```text
스레딩:   OS 관리, 선점형, 실제 스레드 (CPU에 대해 GIL 제한)
asyncio:  단일 스레드, 협력적 — 코루틴이 `await` 지점에서 양보
          → 더 가벼움 (수천 개의 연결 처리), 스레드 오버헤드 없음,
            하지만 하나의 CPU 집약적 코루틴이 모든 것을 차단함 (선점 없음)
```

## 가장 중요한 규칙: 이벤트 루프를 차단하지 말 것

```python
async def bad():
    time.sleep(5)              # ❌ 전체 이벤트 루프를 차단 (동기 sleep)
    result = heavy_compute()    # ❌ CPU 작업이 모든 코루틴을 멈춤

async def good():
    await asyncio.sleep(5)      # ✅ 논블로킹
    # CPU 작업을 스레드/프로세스 풀로 오프로드
    await loop.run_in_executor(None, heavy_compute)
```

협력적이고 단일 스레드이기 때문에 차단/CPU 집약적 호출은 *모든* 코루틴을 멈춥니다. await 가능한 async API를 사용하고, 차단/CPU 작업을 executor로 오프로드하세요.

## asyncio가 빛나는 곳

```text
✓ 고동시성 I/O: 웹 서버(FastAPI), 웹 스크래핑, 많은 API/DB 호출,
  웹소켓, 실시간 앱 — 수천 개의 동시 연결을 효율적으로
✗ CPU 바운드 작업 — 대신 multiprocessing 사용 (asyncio는 도움이 안 됨)
```

## 왜 중요한가

asyncio는 Python에서 **고동시성 I/O**에 대한 현대적인 접근 방식으로, FastAPI 같은 프레임워크를 구동하고 단일 스레드에서 수천 개의 동시 연결을 효율적으로 처리할 수 있게 합니다 — 연결당 스레드보다 훨씬 가볍습니다.

코루틴, `await`, `gather`를 통한 동시 실행, 그리고 특히 **가장 중요한 규칙**(이벤트 루프를 절대 차단하지 말 것; CPU/차단 작업을 오프로드)을 이해하는 것은 성능 좋은 async Python을 작성하는 데 필수적입니다.

언제 적합한지(I/O 바운드 동시성) 대 언제 그렇지 않은지(CPU 바운드 → multiprocessing)를 아는 것이 이를 효과적으로 사용하는 핵심입니다.