서버 개발을 공부하다 보면 한 가지 이상한 점을 발견하게 된다.
CPU가 8코어인 서버가 있다고 가정하자.
물리적인 CPU 코어는 8개뿐인데, 웹 서버는 수천 명에서 수만 명에 이르는 사용자의 연결과 요청을 처리할 수 있다고 한다.
물론 서버의 종류와 작업량에 따라 처리 가능한 규모는 달라지겠지만, 적어도 코어 개수만큼만 요청을 처리하는 것은 아니다.
그렇다면 의문이 생긴다.
CPU가 동시에 실행할 수 있는 작업의 개수는 제한되어 있는데 어떻게 그렇게 많은 사용자를 처리하는 걸까?
여기서 중요한 개념은 동시성과 병렬성의 차이다.
1. 동시성과 병렬성은 다르다
우리는 흔히 여러 작업을 동시에 처리한다고 표현한다.
하지만 CS에서 동시성(Concurrency)과 병렬성(Parallelism)은 구분할 필요가 있다.
동시성은 여러 작업의 진행을 겹쳐 관리하는 것이고, 병렬성은 여러 작업이 실제로 같은 시점에 실행되는 것이다.
예를 들어 CPU 코어가 하나뿐이라고 가정하자.
운영체제는 여러 프로세스나 스레드에 CPU 실행 시간을 번갈아 배분할 수 있다.
시간 ─────────────────────────→
CPU Core 1
[A][B][C][A][B][C][A][B]
실제로는 특정 순간에 하나의 작업만 실행하지만, 매우 빠르게 전환하기 때문에 여러 작업이 함께 진행되는 것처럼 보인다.
반면 CPU 코어가 여러 개라면 서로 다른 작업을 실제로 병렬 실행할 수도 있다.
시간 ─────────────────────────→
Core 1 [A][A][A][A]
Core 2 [B][B][B][B]
Core 3 [C][C][C][C]
Core 4 [D][D][D][D]
이것이 병렬성이다.
그렇다면 수만 개의 요청을 처리하는 서버는 CPU가 엄청나게 빠른 속도로 수만 개의 작업을 전환하고 있는 걸까?
일부는 맞는 설명이지만, 그것만으로 전체 현상을 설명하기는 어렵다.
핵심은 서버의 작업 중 상당 부분이 CPU를 사용하지 않고 기다리는 시간이라는 것이다.
2. 서버는 생각보다 기다리는 시간이 많다
간단한 백엔드 API를 생각해 보자.
@GetMapping("/users/{id}")
public User getUser(@PathVariable Long id) {
return userService.findById(id);
}
코드는 단순하다.
그러나 실제 내부에서는 DB 조회가 발생할 수 있다.
요청 수신
|
▼
요청 파싱 및 로직 실행
|
▼
DB 조회 요청
|
▼
DB 응답 대기
|
▼
응답 생성
|
▼
클라이언트에 반환
여기서 DB 응답을 기다리는 동안 요청 처리 스레드가 반드시 CPU 코어를 계속 점유하고 있을 필요는 없다.
DB나 네트워크 I/O가 완료되기를 기다리는 동안 CPU는 다른 실행 가능한 작업을 처리할 수 있다.
이는 CPU 연산이 많은 작업과 I/O 대기가 많은 작업의 차이다.
| 구분 | CPU Bound | I/O Bound |
|---|---|---|
| 주요 작업 | 복잡한 계산, 인코딩 | DB 조회, 파일 읽기, 네트워크 |
| 주된 병목 | CPU 연산 능력 | I/O 지연과 처리량 |
| 개선 방향 | 알고리즘, 병렬 연산 | 비동기 처리, 동시성 관리 |
가령 하나의 요청에 CPU 계산 시간은 2ms, 외부 I/O 대기는 98ms가 걸린다고 가정하자.
총 응답 시간은 약 100ms이지만, CPU가 실질적으로 작업하는 시간은 그중 일부에 불과하다.
따라서 I/O를 기다리는 동안 다른 요청을 처리한다면 제한된 CPU 자원을 더 효율적으로 활용할 수 있다.
3. 그럼 스레드를 1만 개 만들면 되는 것 아닐까?
가장 먼저 떠올릴 수 있는 방법은 사용자 요청마다 스레드를 하나씩 생성하는 것이다.
전통적인 Java 플랫폼 스레드 기반 서버에서는 요청을 처리하는 스레드가 Blocking I/O를 만나면 해당 스레드는 대기하게 된다.
문제는 스레드가 공짜가 아니라는 것이다.
스레드는 스택과 운영체제 자원을 사용하고, 스케줄링과 컨텍스트 스위칭에도 비용이 발생한다.
스레드가 지나치게 많다면 오히려 시스템의 성능과 안정성이 나빠질 수 있다.
이 문제를 해결하기 위한 접근 중 하나가 Non-blocking I/O다.
Blocking과 Non-blocking
Blocking 방식에서는 호출한 작업이 완료될 때까지 호출 흐름이 대기할 수 있다.
반면 Non-blocking 방식에서는 I/O가 즉시 완료되지 않더라도 실행 흐름이 다른 작업을 계속할 수 있도록 설계한다.
여기서 비동기(Asynchronous)라는 개념도 등장한다.
비동기는 작업 완료를 기다리며 호출 흐름을 계속 붙잡아두지 않고, 결과를 나중에 전달받거나 처리하는 방식이다.
Blocking/Non-blocking과 동기/비동기는 엄밀하게는 서로 다른 구분 기준이지만, 실제 서버 설계에서는 함께 활용되는 경우가 많다.
4. 이벤트 루프는 어떻게 동작할까?
Node.js는 이벤트 루프 기반의 비동기 I/O 모델을 설명할 때 자주 등장한다.
동작을 단순화하면 다음과 같다.
클라이언트 요청
|
▼
Event Loop
|
├── 요청 A: DB I/O 시작
├── 요청 B: 파일 I/O 시작
└── 요청 C: 처리
|
▼
I/O 완료 이벤트
|
▼
콜백 또는 후속 작업 실행
메인 JavaScript 실행 스레드가 I/O 작업이 끝날 때까지 계속 대기하는 대신, 완료 이벤트를 받아 후속 작업을 실행한다.
물론 Node.js의 모든 작업이 하나의 스레드에서 처리되는 것은 아니다. 운영체제의 비동기 I/O 기능과 libuv의 스레드 풀 등이 사용될 수 있다.
그리고 JavaScript 코드가 복잡한 CPU 연산을 오랫동안 수행한다면 이벤트 루프도 지연될 수 있다.
즉, 이벤트 루프가 있다고 해서 CPU 연산까지 자동으로 병렬화되는 것은 아니다.
비동기 I/O가 해결하는 것은 주로 기다리는 동안 실행 자원을 비효율적으로 점유하는 문제다.
5. Java에도 비슷한 해결책이 있다
Java 21에서 정식 도입된 Virtual Thread를 살펴보자.
Virtual Thread는 JVM이 관리하는 경량 스레드다.
전통적인 플랫폼 스레드와 달리, 대기하는 동안 적절한 경우 캐리어 스레드에서 분리될 수 있어 많은 동시 작업을 상대적으로 적은 플랫폼 스레드로 관리할 수 있다.
import java.util.concurrent.*;
public class Main {
public static void main(String[] args)
throws InterruptedException {
try (var executor =
Executors.newVirtualThreadPerTaskExecutor()) {
for (int i = 0; i < 10_000; i++) {
executor.submit(() -> {
Thread.sleep(1000);
return null;
});
}
}
}
}
10,000개의 작업을 Virtual Thread로 제출하는 예시다.
각 작업은 1초 동안 대기한다.
전통적인 플랫폼 스레드 10,000개를 그대로 사용하는 방식과 비교해, 대규모 대기 작업을 더 효율적으로 관리할 수 있는 가능성을 보여준다.
다만 Virtual Thread가 항상 빠른 것은 아니다.
CPU를 지속해서 사용하는 연산에서는 코어 개수라는 물리적 한계가 여전히 존재한다.
또한 실제 서비스에서는 DB 커넥션 풀, 네트워크 연결 수, 메모리, 외부 API의 처리량이 추가적인 제약이 된다.
Virtual Thread가 1만 개 있다고 해서 DB 커넥션도 1만 개가 생기는 것은 아니다.
6. 8코어 서버가 1만 명을 처리한다는 말의 의미
처음 질문으로 돌아가 보자.
CPU가 8코어인데 어떻게 1만 명을 처리할 수 있을까?
핵심은 1만 명의 모든 작업을 같은 순간에 CPU에서 실행하는 것이 아니라는 점이다.
실제 서버는 수많은 연결과 작업을 동시에 관리하면서, 그중 실행 가능한 작업에 CPU 시간을 배분한다.
I/O를 기다리는 작업은 대기 상태로 두고 다른 작업을 처리할 수 있다.
이 과정에서 운영체제의 스케줄링, 스레드, 이벤트 루프, 비동기 I/O 같은 기술이 활용된다.
하지만 동시 처리할 수 있는 요청의 수와 초당 완료할 수 있는 요청의 수는 다르다.
예를 들어 연결된 사용자가 1만 명이라고 해서 서버가 매초 1만 건의 복잡한 요청을 완료할 수 있다는 뜻은 아니다.
동시 연결 수, 동시 실행 작업 수, 처리량(Throughput), 응답 시간(Latency)은 서로 구분해야 한다.
서버 성능의 핵심은 CPU 코어 수를 무작정 늘리는 것이 아니라, CPU가 실제로 해야 할 일과 기다려야 하는 일을 구분하고 제한된 자원을 효율적으로 사용하는 것이다.
생각해 볼 문제
Q1. 동시성과 병렬성의 차이는 무엇인가?
Q2. 스레드 수를 무작정 늘리면 오히려 성능이 나빠질 수 있는 이유는 무엇인가?
Q3. Java Virtual Thread를 도입했는데 DB 응답 시간이 거의 개선되지 않았다. 어떤 부분을 확인해야 할까?