141. 코루틴 (Coroutine)

핵심 인사이트 (3줄 요약)

본질: 코루틴 (Coroutine)은 협력적 멀티태스킹(Cooperative Multitasking)을 구현하는 제어 구조로, 함수가 실행 도중에 자발적으로 중단(yield)하고 나중에 재개(resume)할 수 있는 진입점을 여러 개 가지는 특수한 서브루틴이다.

가치: OS 스레드보다 가벼운 문맥 교환 비용(수백 ns vs 수 μs)으로 수만~수십만 개의 동시 작업을 효율적으로 관리할 수 있어, 고동시성 서버와 게임 엔진에서 핵심 동시성 기법으로 사용된다.

융합: Python async/await, JavaScript Promise, Kotlin Coroutines, C++20 Coroutines 등 현대 언어의 비동기 프로그래밍 모델이 코루틴을 기반으로 구현되며, 이벤트 루프와 결합하여 단일 스레드에서 고동시성을 달성한다.

Ⅰ. 개요 및 필요성 (Context & Necessity)

개념: 일반적인 서브루틴(함수)은 단일 진입점(entry point)에서 시작하여 return 시점에서 종료되는 일방향 실행이다. 반면 코루틴은 진입점이 여러 개이며, 실행 중에 yield를 통해 제어를 호출자(caller)에게 반환하고, 나중에 resume으로 중단 지점부터 재개할 수 있다.
필요성: OS 스레드는 커널이 문맥 교환을 관리하므로 생성·전환 비용이 크다(스레드당 스택 1~8MB, 문맥 교환 1~10μs). I/O 바운드 작업이 많은 환경에서 수만 개 스레드를 생성하면 메모리와 문맥 교환 오버헤드가 병목이 된다. 코루틴은 사용자 공간에서 문맥 전환을 수행하므로, 이러한 오버헤드 없이 수십만 개의 동시 작업을 관리할 수 있다.
💡 비유: 서브루틴은 "한 번 들어가면 끝까지 읽어야 하는 책"이고, 코루틴은 "책갈피를 꽂아두고 나중에 이어서 읽을 수 있는 책"이다.

┌───────────────────────────────────────────────────────────────┐
│       서브루틴 vs 코루틴 — 실행 흐름 비교                     │
├───────────────────────────────────────────────────────────────┤
│                                                               │
│  서브루틴 (함수):                                             │
│  caller ──▶ [함수 시작] ──▶ [함수 끝] ──▶ caller로 복귀       │
│               단일 진입점       단일 종료점                   │
│               │                                   ▲           │
│               └── 한 번만 실행, 중간에 멈출 불가 ──┘          │
│                                                               │
│  코루틴:                                                      │
│  caller ──▶ [코루틴 A 시작] ──yield──▶ caller                 │
│               │                         │                     │
│               │    ┌───────────────────┘                      │
│               │    │                                          │
│               └─resume─▶ [코루틴 A 계속] ──yield──▶ caller    │
│                            │                    │             │
│                            └────────────────────┘             │
│                                                               │
│  특징:                                                        │
│  - 진입점이 여러 개 (재개 시마다 다른 지점)                   │
│  - caller와 coroutine가 양방향 제어 전환                      │
│  - 상태를 자체적으로 보관 (로컬 변수 유지)                    │
└───────────────────────────────────────────────────────────────┘

[다이어그램 해설] 서브루틴은 호출자가 제어권을 넘기면 함수가 끝날 때까지 제어권을 돌려받지 못한다. 반면 코루틴은 yield 시점에서 제어권을 호출자에게 반환하고, resume 호출로 중단 시점부터 다시 실행을 이어간다. 이것이 코루틴이 "협력적(cooperative)"인 이유다 — 코루틴 스스로가 언제 양보할지 결정하기 때문이다. preemptive(선점형) 스레드와 달리, 코루틴은 절대 자신의 의지에 반해 선점되지 않으므로 동기화 문제가 발생하지 않지만, 한 코루틴이 양보하지 않으면 전체 시스템이 멈추는 리스크가 있다.

📢 섹션 요약 비유: 코루틴은 "번갈아 가며 말하는 대화"와 같습니다. 한 사람이 말을 마칠 때까지 기다렸다가, 이어서 말하는 것이 아니라, 중간에 "잠깐요" 하고 상대방에게 말을 넘기는 방식입니다.

Ⅱ. 아키텍처 및 핵심 원리 (Deep Dive)

코루틴 유형

유형	특징	언어 예시
비대칭 (Asymmetric)	yield는 호출자에게만 반환, resume는 호출자만 가능	Python generator (yield/send)
대칭 (Symmetric)	임의 코루틴으로 전환 가능	Lua (coroutine.resume/transfer)
스택리스 (Stackless)	컴파일러가 상태 머신(State Machine)으로 변환	Python async/await, JS async
스택풀 (Stackful)	독립 스택을 가지며, 함수 호출 경로 전체가 보존	Lua coroutine, Go goroutine

async/await 구현 원리

┌────────────────────────────────────────────────────────────────────┐
│         async/await — 컴파일러 변환 예시                           │
├────────────────────────────────────────────────────────────────────┤
│                                                                    │
│  소스 코드 (Python):                                               │
│  async def fetch_data():                                           │
│      data = await read_file()   ① 여기서 일시 중단                 │
│      result = await process(data) ② 여기서 재개                    │
│      return result                                                 │
│                                                                    │
│  컴파일러가 생성한 상태 머신:                                      │
│  ┌─────────────────────────────────────────────┐                   │
│  │ 상태 = INIT                                 │                   │
│  │ ── read_file() 호출 → 상태 = WAIT_FILE    │                     │
│  │ ── 결과 수신 → 상태 = HAVE_DATA            │                    │
│  │ ── process(data) 호출 → 상태 = WAIT_PROC  │                     │
│  │ ── 결과 수신 → 상태 = HAVE_RESULT          │                    │
│  │ ── return result                           │                    │
│  └─────────────────────────────────────────────┘                   │
│                                                                    │
│  ① await에서: 현재 로컬 변수를 클로저에 저장 → 이벤트 루프로 복귀  │
│  ② future 완료 시: 저장된 로컬 변수 복원 → 중단 지점에서 재개      │
└────────────────────────────────────────────────────────────────────┘

[다이어그램 해설] async/await는 컴파일러가 코루틴을 상태 머신(State Machine)으로 변환하는 스택리스 코루틴 구현이다. await 시점에서 현재 함수의 모든 로컬 변수를 힙에 저장하고 제어권을 이벤트 루프에게 반환한다. Future가 완료되면 이벤트 루프가 저장된 변수를 복원하고 중단 지점에서 실행을 재개한다. 이 방식의 장점은 각 코루틴에 독립 스택이 필요 없으므로 메모리 오버헤드가 극히 작다는 것이다. 단점은 await는 코루틴 함수 내부에서만 사용할 수 있고, 일반 함수 내부에서는 await를 호출할 수 없다.

📢 섹션 요약 비유: async/await은 "토스 턴치하는 운동선수"와 같습니다. 공을 던지고( yield), 코트 밖에서 다른 일을 하다가, 공이 돌아오면(resume) 다시 받아서 이어서 처리합니다.

Ⅲ. 융합 비교 및 다각도 분석

비교: 스레드 vs 코루틴 vs 고루틴

비교 항목	OS 스레드	코루틴	고루틴 (Goroutine)
문맥 교환	커널 개입 (1~10μs)	사용자 공간 (~100ns)	런타임 (~100ns)
스택 크기	1~8MB	0 (stackless) ~수KB (stackful)	2~8KB (동적 성장)
동시성 수	수천 개	수십만 개	수백만 개
선점형	가능	불가 (협력적)	런타임이 preemptive 지원
병렬성	다중 코어에서 진정 병렬	단일 코어만	다중 코어 (M:N 스케줄링)

과목 융합 관점

이벤트 루프 (OS): 코루틴은 이벤트 루프와 결합하여 단일 스레드 고동시성을 달성한다. Node.js, Python asyncio, Ruby EventMachine이 이 모델을 사용한다.
네트워크: 비동기 I/O 연산과 코루틴의 조합으로 네트워크 지연을 숨길 수 있다. 수만 개의 동시 연결을 단일 스레드로 처리하는 C10K 문제의 해결책이다.
📢 섹션 요약 비유: 스레드는 "각자의 부엌에서 요리하는 요리사", 코루틴은 "한 명의 요리사가 빵 굽는 동안 수프 끓이기를 번갈아 하는" 방식입니다. 한 명이 요리 사고를 내면 전체가 멈추는 것이 단점이죠.

Ⅳ. 실무 적용 및 기술사적 판단

안티패턴

블로킹 연산을 코루틴 내부에서 수행: time.sleep()이나 동기 I/O를 코루틴 내에서 호출하면 이벤트 루프 전체가 블로킹된다. 반드시 비동기 버전(asyncio.sleep(), aio)을 사용해야 한다.
코루틴 체인에서 예외 미처리: 한 코루틴의 예외가 상위 코루틴으로 전파되지 않으면 조용히 실패(silent failure)한다. try/except로 반드시 예외를 처리해야 한다.
📢 섹션 요약 비유: 코루틴에서 블로킹 연산은 "토스 턴치 도중에 핸드폰을 보는 것"과 같습니다. 전체 게임이 멈춰버립니다. 반드시 비동기 버전을 사용해야 합니다.

Ⅴ. 기대효과 및 결론

참고 표준

C++20: std::coroutine (코루틴 TS 승격)
Python: PEP 492 (async/await), asyncio
JavaScript: ES2017 async/await
📢 섹션 요약 비유: 코루틴은 스레드의 무거움과 콜백 지옥(callback hell) 사이의 "제3의 길"입니다. 커피 한 잔 마시는 사이에 만 개의 작업을 돌릴 수 있는 가벼운 마법입니다.

📌 관련 개념 맵 (Knowledge Graph)

개념 명칭	관계 및 시너지 설명
스레드 (Thread)	코루틴보다 무거운 선점형 동시성 기법
고루틴 (Goroutine)	Go 언어의 코루틴 + M:N 스케줄링 구현
이벤트 루프 (Event Loop)	코루틴과 결합하여 단일 스레드 고동시성 달성
액터 모델 (Actor Model)	Erlang/Akka: 메시지 전달 기반의 다른 동시성 패러다임
C10K 문제	코루틴이 해결하는 1만 동시 연결 문제

👶 어린이를 위한 3줄 비유 설명

코루틴은 "책갈피 꽂아두기"예요. 동화책을 읽다가 장난감 놀이터에 가서 놀다가, 다시 와서 책갈피 꽂아둔 다음 장부터 이어서 읽을 수 있어요.
컴퓨터에서는 여러 일을 동시에 처리하면서, 하나가 기다려야 할 때 다른 일을 먼저 하고 나중에 이어서 하는 똑똑한 방법이에요.
요리사 한 명이 오븐에 빵을 넣고 기다리는 동안, 그 사이에 수프를 끓이고 샐러드를 만들 수 있는 것과 같아요 — 한 명이 여러 가지 요리를 동시에 만드는 거죠!