백프레셔
TCP 수신 윈도, 서버의 단계별 큐, 비동기 스트림의 수요 신호를 따라 백프레셔의 변화와 적용 범위를 살펴본다.
· 마지막 업데이트: 2026-11-07 · 14 min read
개요
파일을 읽는 생산자가 초당 100개를 쏟아내는데 다음 단계의 소비자는 초당 60개밖에 못 쳐낸다면, 그 격차가 이어지는 동안 초마다 40개씩 재고가 쌓이고 아무리 큰 버퍼도 결국 턱밑까지 차오른다.
백프레셔(backpressure)는 이 흐름을 거꾸로 제어해 받는 쪽의 여유분만큼만 보내는 쪽이 생산·전송 속도를 늦추게 만드는 메커니즘이다. 실제 데이터는 상류(생산자)에서 하류(소비자)로 흘러내려 가고, “지금 몇 개를 더 받을 수 있다”는 제어 신호는 하류에서 상류로 거슬러 올라가는데, TCP의 수신 윈도나 비동기 큐의 put 대기, 스트림의 request(n) 수요 신호가 모두 단위는 달라도 이 역방향 제어 고리를 구현한다.
수신자가 받을 수 있는 양을 알려준다
네트워크 프로토콜은 비동기 스트림 라이브러리가 세상에 나오기 훨씬 전부터 이 방식을 썼다. 1981년 제정된 TCP 명세(RFC 793)를 보면 수신 측이 지금 당장 받아들일 수 있는 바이트 수를 윈도(window) 크기로 실어 보내고, 송신 측은 보낼 데이터가 산더미처럼 쌓여 있어도 그 창문 크기를 넘지 않게 전송을 자제한다.1
하지만 커널의 TCP 스택이 바이트를 받아주었다고 해서 애플리케이션이 주문 처리나 동영상 변환까지 끝마친 것은 아니다! 만약 애플리케이션이 소켓에서 데이터를 부지런히 퍼 올려 아무 제한 없는 인메모리 큐에 끝없이 밀어 넣는다면, TCP 수신 버퍼는 텅텅 비워져 송신 측에 “더 보내라”는 신호가 나가는 동안 정작 서버 프로세스 메모리는 안에서 조용히 터져 나가므로 소켓 너머의 내부 작업 단계들까지 대기 고리가 끊기지 않고 이어져야 한다.
참고로 네트워크 공학에서는 흐름 제어(flow control)와 혼잡 제어(congestion control)를 엄격히 구별한다. 수신자가 자기 버퍼 사정을 알리는 것이 흐름 제어이고 송신 측이 중간 네트워크 경로의 대역폭 한계를 살피는 것이 혼잡 제어인데, 현행 TCP 표준인 RFC 9293 역시 수신 윈도와 혼잡 윈도를 별개 변수로 다룬다.2
비동기로 나누면 어디에서 기다릴까
단일 스레드에서 일반 함수를 차례로 부를 때는 앞 함수가 리턴할 때까지 호출자가 저절로 멈춰 기다린다. 반면 생산자와 소비자 사이에 비동기 큐나 별도 Task를 끼워 넣으면 생산자는 소비자가 일을 끝내든 말든 다음 작업감을 계속 찍어낼 수 있기 때문에, 그 사이에 놓인 대기 공간의 상한을 어디에 어떻게 걸지가 곧바로 설계 문제로 떠오른다.
생산자가 큐에 항목을 넣을 때마다 await queue.put()으로 빈자리를 기다린다면 큐가 꽉 차는 순간 생산자도 그 자리에 멈춰 선다. 거꾸로 put을 수행하는 새 Task를 끝없이 찍어내서 던져 놓기만 하면, 정작 큐 크기는 두세 칸으로 묶여 있어도 큐 바깥에서 줄 서 기다리는 Task 객체들이 메모리를 가득 채우게 된다.

위 그림에서 위쪽 화살표는 데이터가 하류로 흐르는 방향이고, 아래쪽 화살표는 대기나 수요 신호가 상류로 거슬러 올라가는 방향이다. 결국 그 상류 신호가 생산자의 다음 행동을 제어한다.
단계별 큐를 제어 지점으로 삼은 서버
서버 아키텍처에서 이 단계별 큐를 전면에 내세운 연구가 2001년 Welsh·Culler·Brewer의 SEDA(Staged Event-Driven Architecture) 논문이다. 저자들은 서버 내부를 여러 처리 단계(stage)로 쪼개고 단계 사이의 이벤트 큐를 밖으로 드러내어, 각 큐에 쌓인 적체량을 보면서 스레드 수나 배치 크기를 동적으로 조절하도록 설계했다.3

이벤트는 입력 큐를 거쳐 처리기로 들어가고 처리기는 다른 단계로 이벤트를 보낸다. 제어기는 이 단계의 자원 사용과 스케줄링을 조절한다. (원문 도해).
논문 §3.3은 큐에 상한(threshold)을 걸어 새 항목을 거절하게 만들고, 큐가 찼을 때 앞 단계가 빈자리를 기다릴지(block) 아니면 아예 이벤트를 버릴지(drop/shed load) 정책을 고를 수 있게 했다. 큐를 중간에 끼워 넣었다는 사실만으로는 상한이 저절로 생기지 않는다! 그 큐를 제어 지점으로 삼아 앞단의 생산 속도를 늦추거나 입구에서 요청을 쳐내야 시스템이 무너지지 않는다.
단계를 잘게 쪼개면 단계별 튜닝은 쉬워지지만, 뒤쪽 단계 하나가 버벅거릴 때 그 압력을 맨 앞단 입구까지 어떻게 타고 올라가게 할지 설계해야 한다. 소켓 통신에서 겪던 흐름 제어 문제를 프로세스 안쪽 파이프라인에서 그대로 다시 만나는 셈이다.
라이브러리 사이에서 주고받는 수요
이 역방향 수요 전달을 비동기 라이브러리들 사이의 공통 표준으로 굳힌 것이 2015년 4월 1.0.0 태그가 찍힌 Reactive Streams로, 서로 다른 비동기 스트림 구현체들이 스레드를 블로킹하지 않으면서도(non-blocking) 백프레셔와 취소 신호를 주고받을 수 있도록 최소한의 인터페이스와 엄격한 규칙을 못 박았다.4

공식 소개 첫 문장은 참여자들이 내세운 목표를 요약하며 개별 신호의 세부 계약은 명세에서 정의한다.5 (원문 도해).
구조는 단순하다. 데이터를 내보내는 Publisher와 받아 쓰는 Subscriber가 연결되면, Subscriber는 Subscription.request(n)을 호출해 자기가 지금 더 받을 수 있는 원소 개수를 숫자로 알리고, Publisher 규칙 1.1은 누적 전송량이 누적 요청량을 절대 넘지 못하게 막으며 Subscription 규칙 3.8은 새 요청량을 기존 잔여 수요에 더해 나간다.6
가령 Subscriber가 처음에 request(2)를 부른 뒤 원소 하나를 건네받았다면 남은 수요는 1이고, 그 상태에서 request(3)을 더 부르면 잔여 수요는 4로 늘어난다. 여기서 주고받는 숫자는 ‘초당 몇 개’ 같은 속도가 아니라 ‘지금 보내도 허락된 원소 개수’일 뿐이라, 생산자 쪽에 보낼 데이터가 바닥나거나 스트림이 일찍 끝나면 요청받은 개수보다 적게 보내고 멈출 수도 있다.
남은 수요가 0인 동안 Publisher는 데이터 원소를 단 하나도 더 보낼 수 없다. 또한 추가 수요는 반드시 양수로 요청해야 하며 request(0)은 ‘잠시 멈춤’이 아니라 규격 위반 오류로 처리되는데, 다만 스트림 완료(onComplete)나 오류(onError) 신호는 데이터 원소가 아니므로 남은 수요가 0이어도 즉시 내려보낼 수 있다.7
이후 Java 9 표준 라이브러리에 들어온 java.util.concurrent.Flow 역시 이 Publisher·Subscriber·Subscription·Processor 네 인터페이스를 그대로 채택했다. 두 라이브러리가 탈 없이 맞물리려면 데이터를 흘려보내는 함수뿐 아니라 수요 요청과 취소, 종료 신호의 순서 계약까지 한 치의 어긋남 없이 맞춰야 한다.8
기다림을 표현하는 방법
방식 | 하류의 제약을 상류에 전달하는 방법 | 살펴볼 범위 |
|---|---|---|
동기 호출·블로킹 쓰기 | 호출이 돌아오기 전까지 다음 전송을 기다린다 | 대기하는 스레드와 자원 |
제한된 비동기 큐 | 큐가 차면 생산자의 | 생산자가 각 완료를 기다리는지 |
pull 방식 | 소비자가 다음 값을 요청할 때 생산을 진행한다 | 내부 선읽기와 별도 큐 |
수요 기반 스트림 | 남은 요청량 안에서 원소를 전달한다 | 전달 원소 수와 실제 처리 중인 작업 |
- 방식
동기 호출·블로킹 쓰기
- 하류의 제약을 상류에 전달하는 방법
호출이 돌아오기 전까지 다음 전송을 기다린다
- 살펴볼 범위
대기하는 스레드와 자원
- 방식
제한된 비동기 큐
- 하류의 제약을 상류에 전달하는 방법
큐가 차면 생산자의
put을 보류한다- 살펴볼 범위
생산자가 각 완료를 기다리는지
- 방식
pull 방식
- 하류의 제약을 상류에 전달하는 방법
소비자가 다음 값을 요청할 때 생산을 진행한다
- 살펴볼 범위
내부 선읽기와 별도 큐
- 방식
수요 기반 스트림
- 하류의 제약을 상류에 전달하는 방법
남은 요청량 안에서 원소를 전달한다
- 살펴볼 범위
전달 원소 수와 실제 처리 중인 작업
대기를 코드로 표현하는 방식도 런타임마다 다르다. 블로킹 큐에서는 운영체제 스레드가 아예 멈춰 서지만, 코루틴이나 async/await 기반 비동기 런타임에서는 코루틴만 잠시 보류(suspend)해 두고 스레드는 다른 일을 처리하러 가는데, Reactive Streams가 제어 신호 교환까지 비차단(non-blocking)으로 요구하는 것도 대기 때문에 스레드가 묶이는 일을 막기 위해서다.9
실무에서 가장 흔히 놓치는 구멍은 ‘원소를 건네받은 시점’과 ‘실제 업무 처리를 끝낸 시점’을 혼동하는 일이다. 만약 Subscriber가 원소를 하나 받자마자 비동기 DB 쿼리 Task만 던져 놓고 그 자리에서 곧바로 request(1)을 불러 다음 원소를 달라고 손 벌리면, 스트림 규격상의 숫자 규칙은 겉으로 다 지켰는데도 뒤쪽에서는 끝나지 않은 DB 작업이 수천 개씩 쌓이며 서버가 뻗어버린다.
큐 두 칸으로 보는 흐름 제어
아래 코드는 Python 3.11 이상에서 돌아가는 두 칸짜리(maxsize=2) 비동기 큐 예제다. 생산자가 값을 하나씩 넣으며 매번 await queue.put()의 완료를 기다리기 때문에, 큐 두 칸이 다 차는 순간 put() 코루틴이 보류되고 이벤트 루프 제어권이 소비자에게로 넘어간다.10
import asyncio
async def produce(queue):
for item in range(6):
await queue.put(item)
await queue.put(None)
async def consume(queue):
values = []
while True:
item = await queue.get()
if item is None:
return values
await asyncio.sleep(0.01)
values.append(item)
async def main():
queue = asyncio.Queue(maxsize=2)
async with asyncio.TaskGroup() as group:
group.create_task(produce(queue))
consumer = group.create_task(consume(queue))
assert consumer.result() == list(range(6))
print(consumer.result()) # [0, 1, 2, 3, 4, 5]
if __name__ == "__main__":
asyncio.run(main())입력은 0부터 5까지 여섯 개고 None은 끝났음을 알리는 종료 표지(sentinel)다. 단일 소비자는 앞선 값들을 차례로 처리한 뒤 None을 만나 루프를 빠져나오며, 부모는 TaskGroup 블록을 나갈 때 두 코루틴이 모두 끝날 때까지 기다리므로 완료 건수를 따로 세는 join()이나 task_done()은 쓰지 않았다.
만약 소비자가 일반 예외를 던지며 죽으면 TaskGroup이 생산자 작업도 함께 취소한다. 주의할 점이 하나 있다. 개별 소비자 코루틴만 따로 골라 CancelledError를 주입하면 일반 자식 실패와 다르게 취급되어 생산자가 멈추지 않으므로, 파이프라인 전체를 함께 내릴 때는 부모 작업을 취소해 수명을 한꺼번에 끝내야 한다.11
이 파이썬 예제는 한 프로세스 안에서 큐 대기로 배압을 전달하지만, Reactive Streams는 표준화된 인터페이스와 신호 규칙으로 컴포넌트 사이에 수요를 주고받는다. 풀려는 문제는 같아도 API와 종료 계약은 각기 다르다.
이번에는 큐가 꽉 찼을 때 기다리지 않고 그 자리에서 거절하는 방식을 보자. 아래 코드는 put_nowait을 써서 한 칸짜리 큐에 두 번째 값을 밀어 넣다가 즉시 QueueFull 예외를 돌려받고 접수를 포기하며, 마지막에 큐에서 꺼내는 값은 처음에 들어간 first 하나뿐이다.12
import asyncio
queue = asyncio.Queue(maxsize=1)
queue.put_nowait("first")
try:
queue.put_nowait("second")
except asyncio.QueueFull:
print("second: not accepted")
print(queue.get_nowait()) # first이번에는 똑같은 한 칸짜리 큐에 await put으로 값을 넣어 보자(Python 3.11 이상). 두 번째 넣기가 시작된 시점을 put_started 이벤트로 맞췄는데, 첫 항목이 큐에 들어앉아 있는 동안에는 두 번째 put이 끝나지 않고 대기한다.
import asyncio
async def main():
queue = asyncio.Queue(maxsize=1)
await queue.put("first")
put_started = asyncio.Event()
async def put_second():
put_started.set()
await queue.put("second")
async with asyncio.TaskGroup() as group:
pending = group.create_task(put_second())
await put_started.wait()
print(pending.done()) # False
first = await queue.get()
await pending
print(first, await queue.get()) # first second
if __name__ == "__main__":
asyncio.run(main())첫 번째 get()이 항목을 꺼내는 즉시 빈칸이 열린다. 눈여겨볼 점은 여기서 첫 항목을 꺼내 변수에 담았을 뿐, 아직 별도의 무거운 업무 처리는 시작조차 하지 않았다는 사실이므로 ‘큐에 빈칸이 나기를 기다리는 것’과 ‘소비자가 실제 업무 처리를 끝내기를 기다리는 것’은 전혀 다른 시점에 일어난다.
버퍼가 차면 무엇을 할 것인가
장치 | 직접 정하는 것 | 함께 정할 내용 |
|---|---|---|
버퍼 상한 | 기다리는 데이터를 얼마나 둘지 | 가득 찼을 때 기다릴지, 거절할지, 버릴지 |
레이트 리미터 | 일정 시간에 허용할 양 | 실제 소비 속도가 줄었을 때의 대응 |
동시 실행 상한 | 동시에 처리할 작업 수 | 실행을 기다리는 요청을 어디에 얼마나 둘지 |
드롭·접수 거절 | 받지 않거나 버릴 항목 | 누락과 재시도를 호출자에게 어떻게 알릴지 |
- 장치
버퍼 상한
- 직접 정하는 것
기다리는 데이터를 얼마나 둘지
- 함께 정할 내용
가득 찼을 때 기다릴지, 거절할지, 버릴지
- 장치
레이트 리미터
- 직접 정하는 것
일정 시간에 허용할 양
- 함께 정할 내용
실제 소비 속도가 줄었을 때의 대응
- 장치
동시 실행 상한
- 직접 정하는 것
동시에 처리할 작업 수
- 함께 정할 내용
실행을 기다리는 요청을 어디에 얼마나 둘지
- 장치
드롭·접수 거절
- 직접 정하는 것
받지 않거나 버릴 항목
- 함께 정할 내용
누락과 재시도를 호출자에게 어떻게 알릴지
큐의 두 칸(maxsize=2)이 묶어 두는 것은 오직 ‘큐 안에서 대기 중인 항목 수’뿐이다. 소비자가 이미 꺼내 들고 처리 중인 항목과 생산자가 다음에 넣으려고 쥐고 있는 항목, 그리고 결과를 차곡차곡 모으는 values 리스트는 전부 그 두 칸 바깥에 놓여 있으므로, 큐의 항목 수 상한과 프로세스 전체 메모리의 바이트 상한은 전혀 다른 범위를 가리킨다.
온도 센서 측정값이나 마우스 이동 이벤트처럼 발생원 자체의 속도를 늦출 수 없는 입력도 있다. 이럴 때는 스트림 입구 경계에서 잠시 버퍼에 담아 두거나, 여러 값을 하나로 합치거나(배치·집계), 넘치는 항목을 과감히 버리는(drop) 정책을 골라야 하며, Reactive Streams 명세 역시 원천 속도를 제어할 수 없는 소스에서는 수요 상한을 지키기 위해 버퍼링이나 드롭이 불가피하다고 설명한다.13
처리 용량을 웃도는 입력이 끝없이 밀려들면 유한한 메모리는 언젠가 반드시 넘친다. 잠깐의 폭주를 받아낼 버퍼를 늘리는 일과 지속 가능한 처리량(throughput)을 키우는 일은 전혀 다른 문제여서, 단 하나의 입력도 버리지 않고 다 살려야 하는 업무라면 결국 상류의 유입을 늦추거나 하류의 처리 체급을 키우는 수밖에 없다.
TCP는 수신 윈도를 띄워 보내고, SEDA는 단계별 큐에 문턱을 걸며, Reactive Streams의 Subscriber는 받을 원소 개수를 숫자로 청구한다. 어떤 시스템을 분석하든 데이터가 흘러내려 가는 화살표 옆에 제약 신호가 거슬러 올라오는 화살표를 나란히 그려 보면, 어느 단계가 무엇을 기다리며 숨을 고르는지가 한눈에 드러난다.
같이 보기
각주
- RFC 793 (1981). RFC 793 §2.6. ↩
- RFC 9293 (2022). RFC 9293 §3.8.2·§3.8.6. ↩
- Welsh, Culler, Brewer. SEDA: An Architecture for Well-Conditioned, Scalable Internet Services (2001). SEDA 논문 §3; 발행 정보. ↩
- Reactive Streams 1.0.0. 1.0.0 기록; 공식 발표. ↩
- Reactive Streams 1.0.4. Reactive Streams 명세. ↩
- Reactive Streams 1.0.4. Reactive Streams 1.0.4 규칙 1.1·3.8. ↩
- Reactive Streams 1.0.4. 명세 규칙 1.2·3.9. ↩
- Oracle. Java SE 9 API. Java 9 Flow; Subscription 계약. ↩
- Reactive Streams. 공식 소개의 문제와 범위. ↩
- Python 3.12. asyncio.Queue. ↩
- Python 3.12. TaskGroup의 실패·취소 규칙. ↩
- Python 3.12. put_nowait의 계약. ↩
- Reactive Streams 1.0.4. Subscriber-controlled queue bounds. ↩