스프링 MVC는 왜 스레드를 최대 200개까지 사용할까

1
// 서블릿 컨테이너의 동작 방식
2
class ServletContainer {
3
    ThreadPool pool = new ThreadPool(200); // 미리 생성
4

5
    void handleRequest(HttpRequest request) {
6
        pool.submit(() -> {
7
            servlet.service(request);
8
            // 요청 처리 완료 후 스레드가 자동으로 풀에 반환됨
9
        });
10
    }
11
}

1
// 서블릿 라이프사이클
2
public class MyServlet extends HttpServlet {
3

4
    // 1. init(): 서블릿이 처음 생성될 때 단 한 번 호출
5
    @Override
6
    public void init(ServletConfig config) throws ServletException {
7
        System.out.println("서블릿 초기화!");
8
        // DB 커넥션 풀 초기화 등의 작업
9
    }
10

11
    // 2. service(): 요청이 올 때마다 호출 (멀티스레드로 동작)
12
    @Override
13
    protected void service(HttpServletRequest req, HttpServletResponse res)
14
            throws ServletException, IOException {
15
        // GET, POST 등 HTTP 메서드에 따라 분기
16
        String method = req.getMethod();
17
        if (method.equals("GET")) {
18
            doGet(req, res);
19
        } else if (method.equals("POST")) {
20
            doPost(req, res);
21
        }
22
    }
23

24
    // 3. destroy(): 서블릿이 제거될 때 단 한 번 호출
25
    @Override
26
    public void destroy() {
27
        System.out.println("서블릿 종료!");
28
        // 리소스 정리
29
    }
30
}

1
// 첫 번째 요청
2
GET http://localhost:8080/myServlet
3
// 응답 시간: 38.50ms (서블릿 초기화 포함)
4

5
// 두 번째 요청
6
GET http://localhost:8080/myServlet
7
// 응답 시간: 6.61ms (서블릿 재사용!)

1
// 위험한 코드!
2
public class DangerousServlet extends HttpServlet {
3
    private int count = 0; // 인스턴스 변수 (공유됨!)
4

5
    @Override
6
    protected void doGet(HttpServletRequest req, HttpServletResponse res)
7
            throws ServletException, IOException {
8
        count++; // 여러 스레드가 동시에 접근!
9
        res.getWriter().write("Count: " + count);
10
    }
11
}
12

13
// 시나리오:
14
// Thread 1: count++ (0 → 1)
15
// Thread 2: count++ (동시에 접근, 1 → 2가 아니라 1 → 1이 될 수도!)
16
// Thread 3: count++ (경쟁 조건 발생!)

1
public class SafeServlet extends HttpServlet {
2
    @Override
3
    protected void doGet(HttpServletRequest req, HttpServletResponse res)
4
            throws ServletException, IOException {
5
        int count = 0; // 지역 변수 (스레드마다 Stack에 따로 생김)
6
        count++;
7
        res.getWriter().write("Count: " + count);
8
    }
9
}

1
public class SynchronizedServlet extends HttpServlet {
2
    private int count = 0;
3

4
    @Override
5
    protected synchronized void doGet(HttpServletRequest req, HttpServletResponse res)
6
            throws ServletException, IOException {
7
        count++; // 한 번에 하나의 스레드만 접근
8
        res.getWriter().write("Count: " + count);
9
    }
10
}

1
// 스프링의 핵심: DispatcherServlet
2
public class DispatcherServlet extends FrameworkServlet {
3

4
    @Override
5
    protected void doService(HttpServletRequest req, HttpServletResponse res)
6
            throws Exception {
7

8
        // 1. 핸들러 매핑: 어떤 컨트롤러가 처리할지 찾기
9
        HandlerExecutionChain handler = getHandler(req);
10
        // GET /api/user → UserController.getUser()
11

12
        // 2. 핸들러 어댑터: 컨트롤러 실행 방법 결정
13
        HandlerAdapter adapter = getHandlerAdapter(handler);
14
        // @RestController면 JSON 반환
15
        // @Controller면 View 이름 반환
16

17
        // 3. 실제 실행
18
        ModelAndView mv = adapter.handle(req, res, handler);
19

20
        // 4. 뷰 렌더링 (필요한 경우)
21
        render(mv, req, res);
22
    }
23
}

1
메모리: 10,000 * 1MB = 10GB
2
컨텍스트 스위칭: 초당 수백만 번
3
CPU: 코어당 2,500개 스레드 스케줄링으로 유효 CPU 시간이 크게 감소

1
// NIO Connector의 동작 방식
2
class NioConnector {
3
    Selector selector = Selector.open();
4
    ThreadPool workerPool = new ThreadPool(200);
5

6
    void acceptConnection(SocketChannel channel) {
7
        // Selector에 등록만 하고 스레드는 할당 안 함
8
        channel.register(selector, SelectionKey.OP_READ);
9
    }
10

11
    void pollLoop() {
12
        while (true) {
13
            // 여러 연결을 동시에 감시
14
            selector.select();
15

16
            for (SelectionKey key : selector.selectedKeys()) {
17
                if (key.isReadable()) {
18
                    // 데이터가 있을 때만 워커 스레드 할당
19
                    SocketChannel ch = (SocketChannel) key.channel();
20
                    workerPool.submit(() -> processRequest(ch));
21
                }
22
            }
23
        }
24
    }
25
}

1
BIO:
2
200개 스레드 = 최대 200개 동시 연결
3

4
NIO:
5
200개 워커 스레드
6
+ Poller 스레드 1개 (Tomcat 8.5+는 커넥터당 1개로 고정)
7
= 최대 8,192개 동시 연결 (Tomcat 8 기본값)

1
// Tomcat 8.5부터
2
<Connector protocol="HTTP/1.1" />
3
// → 자동으로 NIO 사용
4

5
// BIO를 명시적으로 설정해도
6
<Connector protocol="org.apache.coyote.http11.Http11Protocol" />
7
// → 경고 로그와 함께 NIO로 전환됨

1
http-nio-8080-Acceptor-0 (1개)
2
  → 연결 수락
3

4
http-nio-8080-ClientPoller (Tomcat 8.5+는 커넥터당 1개로 고정)
5
  (8.5에서 pollerThreadCount 옵션 제거 — "one poller thread is sufficient". 8.0 이전엔 min(2, 코어수)였음)
6
  → Selector로 연결 감시
7

8
http-nio-8080-exec-1 (10~200개)
9
http-nio-8080-exec-2
10
...
11
http-nio-8080-exec-200
12
  → 실제 요청 처리

1
1. max-connections (8192개) 내의 연결은 Poller가 관리
2
2. accept-count (100개) 까지는 OS 레벨 큐에서 대기
3
3. 두 제한을 모두 초과하면 OS가 TCP SYN을 drop하여 클라이언트에서 Connection refused 발생

1
스레드가 sleep 상태일 때: 약 16KB (물리 RAM)
2
스택을 실제로 쓸 때: 최대 1MB까지 증가

1
스택 메모리:
2
- 최소: 200 * 16KB = 3.2MB
3
- 최대: 200 * 1MB = 200MB
4

5
전체 JVM:
6
- Heap: 예를 들어 2GB (-Xmx2g)
7
- Stack: 200MB (200 threads)
8
- Metaspace: 약 256MB
9
= 총 2.5GB 정도

1
스레드 A 레지스터 저장 → 스레드 B 레지스터 복원 → TLB flush
2
= 약 1-2μs

1
4 / 200 = 0.02 (2%)

1
4 / 2000 = 0.002 (0.2%)
2
2000개 스레드에서는 컨텍스트 스위칭 오버헤드가 급격히 증가한다.
3
코어당 500개 스레드를 스케줄링하면 유효 CPU 시간이 크게 줄어든다.

1
CPU: Pentium III 500MHz
2
RAM: 128-512MB
3
동시 접속자: 수백 명 수준

1
300개 동시 요청: 정상 처리
2
10,000개 요청: timeout 발생

1
15,000개 동시 요청: 정상 처리

1
threads.max=50
2
→ 서버 리소스는 남는데 클라이언트는 대기
3
→ TPS 낮아짐

1
threads.max=2000
2
→ 메모리 부족 (2000 * 1MB = 2GB)
3
→ 컨텍스트 스위칭 과다
4
→ CPU는 100%인데 처리량은 낮음

1
1. 애플리케이션 로직 복잡도 (CPU 사용률)
2
2. I/O 대기 시간 (DB, API 호출)
3
3. 예상 트래픽
4
4. 하드웨어 스펙 (코어 수, RAM)
5
5. DBCP 크기 (DB 커넥션 풀)

1
스레드 풀 크기 = CPU 코어 수 × (1 + 대기 시간 / 처리 시간)

1
CPU: 4코어
2
평균 처리 시간: 100ms
3
평균 I/O 대기: 900ms (DB 쿼리)
4

5
스레드 풀 크기 = 4 × (1 + 900/100)
6
               = 4 × 10
7
               = 40

1
server:
2
  tomcat:
3
    threads:
4
      max: 200          # 최대 워커 스레드
5
      min-spare: 10     # 최소 유지 스레드
6
    accept-count: 100   # 대기 큐 크기
7
    max-connections: 8192  # 최대 동시 연결

1
Spring Boot 2.3 이후: server.tomcat.threads.max
2
Spring Boot 2.3 이전: server.tomcat.max-threads

1
java.lang.OutOfMemoryError: unable to create new native thread

1
최대 스레드 수 = 가용 메모리(MB) / 스택 크기(MB)

1
서버 메모리: 4GB
2
JVM Heap: 2GB (-Xmx2g)
3
남은 메모리: 2GB
4
스레드 스택 크기: 1MB (-Xss1m)
5

6
이론적 최대 스레드: 2048개
7
실제 제한: ulimit -u (예: 1024)
8
→ 1024개까지만 생성 가능

1
// 서버 터트리기 (절대 따라하지 마세요)
2
class ThreadBomb {
3
    public static void main(String[] args) {
4
        int count = 0;
5
        try {
6
            while (true) {
7
                new Thread(() -> {
8
                    try {
9
                        Thread.sleep(Long.MAX_VALUE);
10
                    } catch (InterruptedException e) {
11
                    }
12
                }).start();
13
                count++;
14
                System.out.println("Threads: " + count);
15
            }
16
        } catch (OutOfMemoryError e) {
17
            System.err.println("터졌다! " + count + "개 스레드에서 사망");
18
            // Threads: 12543
19
            // java.lang.OutOfMemoryError: unable to create new native thread
20
        }
21
    }
22
}

1
톰캣 설정:
2
- threads.max: 200
3
- accept-count: 100
4
- max-connections: 8192
5

6
상황:
7
1. 200개 스레드 전부 DB 쿼리 대기 중 (각 10초씩)
8
2. accept-count 큐도 100개 꽉 참
9
3. 301번째 요청부터는 connection refused

1
org.apache.tomcat.util.threads.ThreadPoolExecutor
2
All threads (200) are currently busy

1
@RestController
2
class StreamController {
3

4
    @GetMapping("/api/stream/{id}")
5
    public StreamResponse getStream(@PathVariable Long id) {
6
        // DB 조회 - 평균 100ms
7
        Stream stream = streamRepository.findById(id);
8

9
        // 외부 API 호출 - 평균 500ms
10
        User user = oauthClient.getUserInfo(stream.userId);
11

12
        // Redis 조회 - 평균 10ms
13
        ViewCount views = redisTemplate.get(stream.id);
14

15
        return new StreamResponse(stream, user, views);
16
    }
17
}

1
1. 200개 스레드가 전부 OAuth 대기
2
2. 신규 요청은 큐에서 대기
3
3. 큐마저 꽉 차면 connection refused
4
4. 사용자는 "서버 점검 중" 페이지만 봄

1
java.lang.OutOfMemoryError: Java heap space

1
// 위험한 코드
2
class UserContext {
3
    private static final ThreadLocal<User> CURRENT_USER =
4
        new ThreadLocal<>();
5

6
    public static void setUser(User user) {
7
        CURRENT_USER.set(user);
8
        // remove() 안 하면 메모리 누수!
9
    }
10
}
11

12
@RestController
13
class UserController {
14

15
    @GetMapping("/api/user")
16
    public UserResponse getUser() {
17
        User user = userService.findUser();
18
        UserContext.setUser(user); // 설정만 하고
19
        return new UserResponse(user);
20
        // remove() 안 함 → 스레드가 재사용될 때 남아있음
21
    }
22
}

1
// 위험한 코드
2
@Service
3
class EventProcessor {
4
    private final Queue<Event> queue =
5
        new LinkedBlockingQueue<>(); // 크기 제한 없음!
6

7
    @Async
8
    public void processEvent(Event event) {
9
        queue.offer(event);
10
    }
11
}

1
@RestController
2
class UserController {
3

4
    @GetMapping("/api/user")
5
    public UserResponse getUser() {
6
        try {
7
            User user = userService.findUser();
8
            UserContext.setUser(user);
9
            return new UserResponse(user);
10
        } finally {
11
            UserContext.remove(); // 꼭 정리!
12
        }
13
    }
14
}

1
@Configuration
2
class AsyncConfig {
3
    @Bean
4
    public Executor taskExecutor() {
5
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
6
        executor.setQueueCapacity(1000); // 크기 제한!
7
        executor.setRejectedExecutionHandler(
8
            new ThreadPoolExecutor.CallerRunsPolicy()
9
        );
10
        return executor;
11
    }
12
}

1
요청 관련:
2
- requestCount: 처리된 총 요청 수
3
- processingTime: 누적 처리 시간
4
- maxTime: 최대 처리 시간
5

6
스레드 관련:
7
- currentThreadsBusy: 현재 사용 중인 스레드
8
- maxThreads: 최대 스레드 수
9

10
리소스 관련:
11
- HeapMemoryUsage: JVM 메모리 사용량
12
- CollectionCount: GC 횟수

1
I/O 작업 많으면 (DB 쿼리, API 호출):
2
→ 스레드 늘려도 됨 (500~1000)
3

4
CPU 작업 많으면 (이미지 처리, 암호화):
5
→ 코어 수 * 2 정도로 제한
6

7
동시 접속 만 명 이상:
8
→ Virtual Threads 고려 (Java 21+)