Blocking vs Non-Blocking

1
2

data = file.read()  # 이 줄에서 멈춤 (파일 읽기가 끝날 때까지)
print(data)         # 읽기가 완료된 후에야 실행됨

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

상황: 은행 창구에서 업무 처리

[Blocking 방식]
1. 번호표 뽑기
2. 의자에 앉아서 대기 (다른 일 못 함)
3. 내 번호 호출될 때까지 계속 기다림
4. 창구 가서 업무 처리
5. 완료 후 다음 일 시작

→ 기다리는 동안 아무것도 못 함

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

# blocking_example.py
# Blocking I/O로 파일 읽기

import time

def read_file_blocking(filename):
    """블로킹 방식으로 파일을 읽는 함수"""
    print(f"[시작] {filename} 읽기 시작")
    
    # 파일을 열고 읽기 (여기서 블로킹 발생)
    with open(filename, 'r') as f:
        data = f.read()  # 파일을 다 읽을 때까지 여기서 멈춤
    
    print(f"[완료] {filename} 읽기 완료 ({len(data)} bytes)")
    return data

# 메인 실행
print("=== Blocking I/O 예제 ===")
start_time = time.time()

# 파일 3개를 순차적으로 읽기
data1 = read_file_blocking("file1.txt")  # 1번 파일 읽기 (블로킹)
data2 = read_file_blocking("file2.txt")  # 2번 파일 읽기 (블로킹)
data3 = read_file_blocking("file3.txt")  # 3번 파일 읽기 (블로킹)

end_time = time.time()
print(f"\n총 소요 시간: {end_time - start_time:.2f}초")

# 출력 예시:
# === Blocking I/O 예제 ===
# [시작] file1.txt 읽기 시작
# [완료] file1.txt 읽기 완료 (1024 bytes)
# [시작] file2.txt 읽기 시작
# [완료] file2.txt 읽기 완료 (2048 bytes)
# [시작] file3.txt 읽기 시작
# [완료] file3.txt 읽기 완료 (512 bytes)
# 
# 총 소요 시간: 0.15초

1
2
3
4
5

# 파일 읽기 시작 (기다리지 않고 바로 반환)
file.read_async(callback=on_data_ready)
print("다른 작업 수행")  # 읽기가 끝나지 않아도 즉시 실행됨

# 나중에 데이터가 준비되면 callback 함수가 자동으로 호출됨

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

상황: 패스트푸드 주문

[Non-Blocking 방식]
1. 카운터에서 주문
2. 진동벨 받기
3. 의자에 앉아서 스마트폰 사용 (다른 일 가능!)
4. 벨이 울리면 → 카운터 가서 음식 받기
5. 다시 앉아서 다음 벨 대기 (다른 주문도 동시에 처리 가능)

→ 기다리는 동안 다른 일을 할 수 있음

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

# non_blocking_example.py
# Non-Blocking I/O로 파일 읽기 (asyncio 사용)

import asyncio
import time

async def read_file_async(filename):
    """논블로킹 방식으로 파일을 읽는 비동기 함수"""
    print(f"[시작] {filename} 읽기 시작")
    
    # 비동기 파일 읽기 시뮬레이션 (실제로는 aiofiles 사용)
    # await는 "기다리되, 다른 작업도 허용"의 의미
    await asyncio.sleep(0.05)  # I/O 대기 시뮬레이션
    
    # 파일 읽기 (실제로는 with aiofiles.open()...)
    with open(filename, 'r') as f:
        data = f.read()
    
    print(f"[완료] {filename} 읽기 완료 ({len(data)} bytes)")
    return data

async def main():
    """메인 비동기 함수"""
    print("=== Non-Blocking I/O 예제 ===")
    start_time = time.time()
    
    # 파일 3개를 동시에 읽기 시작 (블로킹 없이!)
    # asyncio.gather는 여러 작업을 동시에 실행
    results = await asyncio.gather(
        read_file_async("file1.txt"),  # 동시 실행 1
        read_file_async("file2.txt"),  # 동시 실행 2
        read_file_async("file3.txt"),  # 동시 실행 3
    )
    
    end_time = time.time()
    print(f"\n총 소요 시간: {end_time - start_time:.2f}초")
    print(f"읽은 파일 수: {len(results)}개")

# 비동기 실행
asyncio.run(main())

# 출력 예시:
# === Non-Blocking I/O 예제 ===
# [시작] file1.txt 읽기 시작
# [시작] file2.txt 읽기 시작
# [시작] file3.txt 읽기 시작
# [완료] file1.txt 읽기 완료 (1024 bytes)
# [완료] file2.txt 읽기 완료 (2048 bytes)
# [완료] file3.txt 읽기 완료 (512 bytes)
# 
# 총 소요 시간: 0.05초  ← Blocking보다 3배 빠름!
# 읽은 파일 수: 3개

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

[Blocking I/O - 순차 처리]
시간 →
스레드1: [파일1 읽기 ████] → [파일2 읽기 ████] → [파일3 읽기 ████]
         대기...            대기...            대기...
         
총 시간: ████████████ (12초)


[Non-Blocking I/O - 병렬 처리]
시간 →
스레드1: [파일1] [파일2] [파일3] → [모두 처리] ████
         시작    시작    시작      동시 대기...
         
총 시간: ████ (4초)

1
2
3
4
5
6
7
8
9

1. 애플리케이션 요청
   ↓
2. 시스템 콜 호출 (유저 공간 → 커널 공간)
   ↓
3. 커널 데이터 준비 (디스크/네트워크에서 읽기)
   ↓
4. 데이터 복사 (커널 버퍼 → 유저 버퍼)
   ↓
5. 애플리케이션으로 제어 반환

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

유저 프로세스              커널                    디바이스
    |                      |                        |
    | read(fd, buf, size)  |                        |
    |--------------------->|                        |
    |                      | 데이터 요청            |
    |                      |----------------------->|
    | [블로킹 대기]        | [커널 버퍼 대기]       |
    | (다른 작업 불가)     |                        |
    |                      |<-----------------------|
    |                      | 데이터 도착            |
    |                      | [커널 버퍼 → 유저]    |
    |<---------------------|                        |
    | 반환 (데이터 포함)   |                        |
    | [작업 재개]          |                        |

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

유저 프로세스              커널                    디바이스
    |                      |                        |
    | fcntl(fd, F_SETFL, O_NONBLOCK)               |
    |--------------------->|                        |
    |                      |                        |
    | read(fd, buf, size)  |                        |
    |--------------------->|                        |
    |                      | 데이터 준비 확인       |
    |                      | [준비 안 됨!]         |
    |<---------------------|                        |
    | 즉시 반환 (EAGAIN)   |                        |
    | [다른 작업 수행]     |                        |
    |                      |                        |
    | select([fd], ...)    | 데이터 요청            |
    |--------------------->|----------------------->|
    | [이벤트 대기]        |                        |
    |                      |<-----------------------|
    |                      | 데이터 도착            |
    |<---------------------|                        |
    | FD 준비됨 반환       |                        |
    |                      |                        |
    | read(fd, buf, size)  |                        |
    |--------------------->|                        |
    |                      | [커널 버퍼 → 유저]    |
    |<---------------------|                        |
    | 반환 (데이터 포함)   |                        |

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

[초기화 단계]
1. socket() → fd 생성
2. bind(), listen(), accept() → 연결 수락
3. fd는 기본적으로 Blocking 모드

[읽기 단계]
시간  유저 공간                커널 공간               네트워크
t0   |                         |                       |
     | recv(fd, buf, 1024)     |                       |
t1   |------------------------>| socket buffer 확인    |
     |                         | [비어있음!]           |
     |                         | 프로세스 → 대기 큐    |
t2   | [블로킹 대기 시작]      |                       |
     | CPU 양보                |                       |
     |                         |                       | 데이터 전송 중...
t3   |                         |                       |<------[패킷 도착]
     |                         | 인터럽트 발생         |
     |                         | socket buffer 채움    |
t4   |                         | 프로세스 깨우기       |
     |                         | 대기 큐 → RUNNABLE    |
t5   |                         | copy_to_user()        |
     |                         | kernel buf → user buf |
t6   |<------------------------| 반환 (1024 bytes)     |
     | [실행 재개]             |                       |
     | 다음 코드 실행          |                       |

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

[초기화 단계]
1. socket() → fd 생성
2. fcntl(fd, F_SETFL, O_NONBLOCK) → Non-Blocking 설정
3. epoll_create1(0) → epfd 생성
4. epoll_ctl(epfd, EPOLL_CTL_ADD, fd, ...) → fd 등록

[이벤트 루프 단계]
시간  유저 공간                커널 공간               네트워크
t0   |                         |                       |
     | epoll_wait(epfd, ...)   |                       |
t1   |------------------------>| 등록된 FD 확인        |
     |                         | [모두 준비 안 됨]     |
     | [대기]                  |                       |
     |                         |                       | 데이터 전송 중...
t2   |                         |                       |<------[패킷 도착]
     |                         | 인터럽트 발생         |
     |                         | socket buffer 채움    |
     |                         | epoll 이벤트 큐에 추가|
t3   |<------------------------| epoll_wait 반환       |
     | [이벤트 감지]           | (fd, EPOLLIN)         |
     |                         |                       |
     | recv(fd, buf, 1024)     |                       |
t4   |------------------------>| copy_to_user()        |
     |                         | kernel buf → user buf |
t5   |<------------------------| 반환 (1024 bytes)     |
     | 콜백 함수 호출          |                       |
     | process_data(buf)       |                       |
t6   |                         |                       |
     | epoll_wait() 재호출     |                       |
     | (다음 이벤트 대기)      |                       |

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

# blocking_server.py - 개념 설명용 간소화 버전
import socket
import threading

def handle_client_blocking(client_sock, addr):
    """각 클라이언트를 전담 스레드에서 처리"""
    print(f"[스레드 {threading.current_thread().name}] 클라이언트 {addr} 연결")
    
    try:
        # 1. 요청 읽기 (블로킹!)
        request = client_sock.recv(4096)  # 여기서 대기
        print(f"  요청 수신: {len(request)} bytes")
        
        # 2. 처리 (여기서도 블로킹 가능)
        # 예: 데이터베이스 쿼리, 파일 읽기 등
        response = b"HTTP/1.1 200 OK\r\n\r\nHello, World!"
        
        # 3. 응답 쓰기 (블로킹!)
        client_sock.sendall(response)  # 여기서도 대기 가능
        
    finally:
        client_sock.close()
        print(f"[스레드 {threading.current_thread().name}] 연결 종료")

def blocking_server(port=8080):
    """Blocking 웹 서버 메인"""
    server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server_sock.bind(('0.0.0.0', port))
    server_sock.listen(128)  # 백로그 큐
    
    print(f"Blocking 서버 시작: 포트 {port}")
    
    while True:
        # accept()도 블로킹 시스템 콜!
        client_sock, addr = server_sock.accept()  # 연결 올 때까지 대기
        
        # 각 연결마다 새 스레드 생성 (Thread-per-connection)
        thread = threading.Thread(
            target=handle_client_blocking,
            args=(client_sock, addr)
        )
        thread.start()
        # 주의: 스레드가 계속 증가하면 메모리/CPU 고갈!

# 실행
if __name__ == '__main__':
    blocking_server()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

# non_blocking_server.py - asyncio 사용
import asyncio

async def handle_client_nonblocking(reader, writer):
    """각 클라이언트를 비동기로 처리"""
    addr = writer.get_extra_info('peername')
    print(f"[이벤트 루프] 클라이언트 {addr} 연결")
    
    try:
        # 1. 요청 읽기 (Non-Blocking, 다른 연결도 동시 처리 가능)
        request = await reader.read(4096)  # await: 양보 가능 지점
        print(f"  요청 수신: {len(request)} bytes")
        
        # 2. 처리
        response = b"HTTP/1.1 200 OK\r\n\r\nHello, World!"
        
        # 3. 응답 쓰기 (Non-Blocking)
        writer.write(response)
        await writer.drain()  # 버퍼 플러시 대기
        
    finally:
        writer.close()
        await writer.wait_closed()
        print(f"[이벤트 루프] 연결 종료")

async def non_blocking_server(port=8080):
    """Non-Blocking 웹 서버 메인"""
    server = await asyncio.start_server(
        handle_client_nonblocking,
        '0.0.0.0',
        port
    )
    
    addr = server.sockets[0].getsockname()
    print(f"Non-Blocking 서버 시작: 포트 {addr[1]}")
    
    async with server:
        await server.serve_forever()  # 이벤트 루프 실행

# 실행
if __name__ == '__main__':
    asyncio.run(non_blocking_server())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

[10개 동시 연결 시 시간 흐름]

스레드1: [recv ████] [처리] [send ██]
스레드2:    [recv ████] [처리] [send ██]
스레드3:       [recv ████] [처리] [send ██]
...
스레드10:            [recv ████] [처리] [send ██]

CPU: [1→2→3→1→4→2→5→3→1→6→...] (빈번한 전환)
     ↑ 컨텍스트 스위칭 오버헤드: 전환당 ~5μs

1
2
3
4
5
6
7

[10개 동시 연결 시 시간 흐름]

이벤트 루프: [epoll_wait] → [FD1 처리] → [FD2 처리] → [FD5 처리] → [epoll_wait] → ...
                ↑            ↑             ↑             ↑
             모두 대기     준비됨        준비됨        준비됨

CPU: [루프→루프→루프→...] (전환 없음, 캐시 히트율 높음)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

하드웨어:
  CPU: Intel Xeon E5-2680 v4 @ 2.4GHz (8 vCore)
  메모리: 16GB DDR4
  네트워크: 10Gbps
  디스크: NVMe SSD 500GB

소프트웨어:
  OS: Ubuntu 22.04 LTS (Kernel 6.1)
  Python: 3.11.5
  Node.js: 20.10.0 LTS
  
워크로드:
  시나리오: HTTP Echo 서버 (10KB 응답)
  도구: wrk (HTTP 벤치마크)
  동시 연결: 100, 1,000, 10,000
  테스트 시간: 각 5분
  반복: 10회 평균

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

[의사결정 트리]

시작
 │
 ├─ 동시 연결 수는?
 │   ├─ < 100: Blocking (단순성 우선)
 │   ├─ 100~1,000: 둘 다 가능 (팀 역량 고려)
 │   └─ > 1,000: Non-Blocking (필수)
 │
 ├─ 워크로드 특성은?
 │   ├─ I/O bound (네트워크, 파일): Non-Blocking 유리
 │   ├─ CPU bound (계산, 암호화): Blocking 또는 하이브리드
 │   └─ 혼합: 하이브리드 (Nginx + Blocking 워커)
 │
 ├─ 팀 역량은?
 │   ├─ 초급: Blocking (학습 비용 낮음)
 │   ├─ 중급: 둘 다 가능
 │   └─ 고급: Non-Blocking (최적화 가능)
 │
 ├─ 응답 시간 SLA는?
 │   ├─ p99 < 100ms: Non-Blocking 권장
 │   ├─ p99 < 500ms: 둘 다 가능
 │   └─ SLA 없음: Blocking (개발 속도)
 │
 └─ 클라우드 비용 민감도는?
     ├─ 매우 민감: Non-Blocking (메모리 1/10)
     ├─ 보통: 둘 다 가능
     └─ 비용 < 개발 속도: Blocking

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

코드 필요성: 필수
이유:
  - Blocking/Non-Blocking은 코드 레벨에서 명확히 다름
  - 실무 패턴 이해를 위해 실행 가능한 예제 필수
  - 프레임워크 선택에 직접적 영향

대체 방안: 불가
  - 의사코드로는 이벤트 루프, 콜백 메커니즘 설명 부족
  - 설정 예시만으로는 실무 적용 어려움

언어 선택:
  - Python: asyncio (학습 친화적, 실무 활용 높음)
  - JavaScript: Node.js (Non-Blocking 대표)
  - Java: NIO, CompletableFuture (엔터프라이즈)

제약 사항:
  - 각 예제 150줄 이하
  - 주석으로 핵심 개념 설명
  - 실행 가능하고 테스트 가능한 코드

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

#!/usr/bin/env python3
"""
blocking_http_server.py
Blocking I/O 방식의 간단한 HTTP Echo 서버
Thread Pool을 사용하여 동시 연결 처리
"""

import socket
import threading
from concurrent.futures import ThreadPoolExecutor
import time

# 설정
HOST = '0.0.0.0'
PORT = 8080
MAX_WORKERS = 50  # 스레드 풀 크기
BUFFER_SIZE = 4096

class BlockingHTTPServer:
    """Blocking HTTP 서버 (Thread Pool 패턴)"""
    
    def __init__(self, host, port, max_workers):
        self.host = host
        self.port = port
        self.max_workers = max_workers
        self.executor = ThreadPoolExecutor(max_workers=max_workers)
        self.active_connections = 0
        self.lock = threading.Lock()
        
    def handle_client(self, client_sock, addr):
        """각 클라이언트 요청을 처리하는 워커 함수 (블로킹)"""
        thread_id = threading.current_thread().name
        
        # 활성 연결 수 증가
        with self.lock:
            self.active_connections += 1
            print(f"[{thread_id}] 연결: {addr}, 활성: {self.active_connections}")
        
        try:
            # 1. 요청 읽기 (블로킹!)
            # recv()는 데이터가 도착할 때까지 이 스레드를 대기시킴
            request_data = client_sock.recv(BUFFER_SIZE)
            
            if not request_data:
                return
            
            # 요청 파싱 (간단히 첫 줄만)
            request_line = request_data.decode('utf-8', errors='ignore').split('\r\n')[0]
            print(f"[{thread_id}] 요청: {request_line}")
            
            # 2. 비즈니스 로직 (예: 느린 작업 시뮬레이션)
            # 실제로는 DB 쿼리, 파일 읽기 등이 여기서 블로킹 발생
            time.sleep(0.1)  # 100ms 처리 시뮬레이션
            
            # 3. 응답 생성
            response_body = f"Echo: {request_line}\nThread: {thread_id}\n"
            response = (
                "HTTP/1.1 200 OK\r\n"
                "Content-Type: text/plain; charset=utf-8\r\n"
                f"Content-Length: {len(response_body)}\r\n"
                "Connection: close\r\n"
                "\r\n"
                f"{response_body}"
            )
            
            # 4. 응답 쓰기 (블로킹!)
            # sendall()은 모든 데이터를 보낼 때까지 대기
            client_sock.sendall(response.encode('utf-8'))
            
        except Exception as e:
            print(f"[{thread_id}] 에러: {e}")
            
        finally:
            client_sock.close()
            
            # 활성 연결 수 감소
            with self.lock:
                self.active_connections -= 1
                print(f"[{thread_id}] 종료: {addr}, 활성: {self.active_connections}")
    
    def start(self):
        """서버 시작"""
        # 소켓 생성 (기본적으로 Blocking 모드)
        server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        server_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        server_sock.bind((self.host, self.port))
        server_sock.listen(128)  # 백로그 큐 크기
        
        print(f"Blocking HTTP 서버 시작: http://{self.host}:{self.port}")
        print(f"스레드 풀 크기: {self.max_workers}")
        
        try:
            while True:
                # accept()도 블로킹! 연결이 올 때까지 메인 스레드 대기
                client_sock, addr = server_sock.accept()
                
                # 스레드 풀에 작업 제출 (비동기 실행)
                self.executor.submit(self.handle_client, client_sock, addr)
                
        except KeyboardInterrupt:
            print("\n서버 종료 중...")
        finally:
            server_sock.close()
            self.executor.shutdown(wait=True)
            print("서버 종료 완료")

if __name__ == '__main__':
    server = BlockingHTTPServer(HOST, PORT, MAX_WORKERS)
    server.start()

"""
특징:
1. accept(), recv(), sendall() 모두 블로킹 시스템 콜
2. 각 연결마다 스레드 풀에서 워커 스레드 할당
3. 스레드 수 = 동시 처리 가능한 연결 수
4. 간단하고 직관적이지만 동시성 제한

테스트:
$ python blocking_http_server.py &
$ curl http://localhost:8080/test
Echo: GET /test HTTP/1.1
Thread: ThreadPoolExecutor-0_0

벤치마크:
$ wrk -t4 -c100 -d10s http://localhost:8080/
  - 100 동시 연결: 정상 동작
  - 1000 동시 연결: 스레드 풀 포화, 대기 발생
"""

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

#!/usr/bin/env python3
"""
non_blocking_http_server.py
Non-Blocking I/O 방식의 HTTP Echo 서버
asyncio를 사용한 단일 스레드 이벤트 루프
"""

import asyncio
import time

# 설정
HOST = '0.0.0.0'
PORT = 8080

class NonBlockingHTTPServer:
    """Non-Blocking HTTP 서버 (asyncio 이벤트 루프)"""
    
    def __init__(self, host, port):
        self.host = host
        self.port = port
        self.active_connections = 0
    
    async def handle_client(self, reader, writer):
        """
        각 클라이언트 요청을 비동기로 처리
        reader: asyncio.StreamReader (Non-Blocking 읽기)
        writer: asyncio.StreamWriter (Non-Blocking 쓰기)
        """
        addr = writer.get_extra_info('peername')
        
        # 활성 연결 수 증가 (단일 스레드라 락 불필요!)
        self.active_connections += 1
        print(f"[이벤트 루프] 연결: {addr}, 활성: {self.active_connections}")
        
        try:
            # 1. 요청 읽기 (Non-Blocking!)
            # await는 "다른 코루틴도 실행 가능"을 의미
            # 데이터를 기다리는 동안 다른 연결도 처리됨
            request_data = await reader.read(4096)
            
            if not request_data:
                return
            
            # 요청 파싱
            request_line = request_data.decode('utf-8', errors='ignore').split('\r\n')[0]
            print(f"[이벤트 루프] 요청: {request_line}")
            
            # 2. 비동기 비즈니스 로직
            # asyncio.sleep()은 Non-Blocking (다른 연결도 동시 처리)
            await asyncio.sleep(0.1)  # 100ms 처리 시뮬레이션
            
            # 실제로는 비동기 DB 쿼리, 파일 읽기 등
            # await db.fetch_one("SELECT ...")
            # await aiofiles.open("file.txt").read()
            
            # 3. 응답 생성
            response_body = f"Echo: {request_line}\nAsync: True\n"
            response = (
                "HTTP/1.1 200 OK\r\n"
                "Content-Type: text/plain; charset=utf-8\r\n"
                f"Content-Length: {len(response_body)}\r\n"
                "Connection: close\r\n"
                "\r\n"
                f"{response_body}"
            )
            
            # 4. 응답 쓰기 (Non-Blocking!)
            writer.write(response.encode('utf-8'))
            await writer.drain()  # 버퍼 플러시 대기 (다른 연결도 실행 가능)
            
        except Exception as e:
            print(f"[이벤트 루프] 에러: {e}")
            
        finally:
            writer.close()
            await writer.wait_closed()
            
            # 활성 연결 수 감소
            self.active_connections -= 1
            print(f"[이벤트 루프] 종료: {addr}, 활성: {self.active_connections}")
    
    async def start(self):
        """서버 시작 (비동기 메인 함수)"""
        # asyncio.start_server: Non-Blocking 서버 소켓 생성
        server = await asyncio.start_server(
            self.handle_client,
            self.host,
            self.port
        )
        
        addr = server.sockets[0].getsockname()
        print(f"Non-Blocking HTTP 서버 시작: http://{addr[0]}:{addr[1]}")
        print("단일 스레드 이벤트 루프 실행 중...")
        
        # 서버 실행 (이벤트 루프가 계속 돌면서 연결 감지)
        async with server:
            await server.serve_forever()

def main():
    """메인 함수 (이벤트 루프 시작)"""
    server = NonBlockingHTTPServer(HOST, PORT)
    
    try:
        # asyncio.run()이 이벤트 루프를 생성하고 실행
        asyncio.run(server.start())
    except KeyboardInterrupt:
        print("\n서버 종료")

if __name__ == '__main__':
    main()

"""
특징:
1. 모든 I/O가 Non-Blocking (await 키워드)
2. 단일 스레드로 수만 개 동시 연결 처리 가능
3. 이벤트 루프가 준비된 작업만 실행
4. 높은 동시성, 낮은 메모리 사용

내부 동작 (간소화):
while True:  # 이벤트 루프
    ready_tasks = epoll_wait()  # 준비된 I/O 확인
    for task in ready_tasks:
        task.resume()  # 코루틴 재개
    
    expired_timers = check_timers()
    for timer in expired_timers:
        timer.callback()

테스트:
$ python non_blocking_http_server.py &
$ curl http://localhost:8080/test
Echo: GET /test HTTP/1.1
Async: True

벤치마크:
$ wrk -t4 -c10000 -d10s http://localhost:8080/
  - 10,000 동시 연결: 정상 동작 (메모리 < 500MB)
  - CPU 사용률: 30~40% (단일 코어)
"""

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138