스레드 풀 튜닝 — Tomcat과 @Async의 스레드 설정 최적화

server:
  tomcat:
    threads:
      max: 200          # 최대 워커 스레드 수 (기본: 200)
      min-spare: 10     # 유휴 스레드 최소 수 (기본: 10)
    accept-count: 100   # 대기 큐 크기 (기본: 100)
    max-connections: 8192  # 최대 동시 커넥션 수 (기본: 8192)
    connection-timeout: 20000  # 커넥션 타임아웃 ms

[클라이언트 요청]
    ↓
[max-connections(8192) 체크] → 초과 시 즉시 거부
    ↓
[워커 스레드 할당 시도]
    ├─ 유휴 스레드 있음 → 즉시 처리
    └─ 모든 스레드 사용 중
        ↓
    [acceptCount(100) 큐에 대기]
        ├─ 큐에 공간 있음 → 대기
        └─ 큐도 가득 참 → 연결 거부

적정 스레드 수 = 동시 사용자 수 × 평균 요청 처리 시간 / 평균 요청 간격

@Configuration
@EnableAsync  // 비동기 활성화
public class AsyncConfig {
}

@Service
public class NotificationService {

    @Async
    public void sendEmailAsync(String to, String content) {
        // 별도 스레드에서 실행 — 호출자는 기다리지 않음
        emailClient.send(to, content);
    }

    @Async
    public CompletableFuture<UserProfile> fetchProfileAsync(Long userId) {
        UserProfile profile = userApi.getProfile(userId);
        return CompletableFuture.completedFuture(profile);
    }
}

@Configuration
@EnableAsync
public class AsyncConfig {

    @Bean("emailExecutor")
    public TaskExecutor emailTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);         // 기본 스레드 수
        executor.setMaxPoolSize(10);         // 최대 스레드 수
        executor.setQueueCapacity(50);       // 큐 크기
        executor.setThreadNamePrefix("email-");
        executor.setRejectedExecutionHandler(
            new ThreadPoolExecutor.CallerRunsPolicy());  // 거부 정책
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(30);
        executor.initialize();
        return executor;
    }

    @Bean("reportExecutor")
    public TaskExecutor reportTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);
        executor.setMaxPoolSize(5);
        executor.setQueueCapacity(20);
        executor.setThreadNamePrefix("report-");
        executor.initialize();
        return executor;
    }
}

@Service
public class NotificationService {

    @Async("emailExecutor")  // 특정 executor 지정
    public void sendEmail(String to, String content) {
        emailClient.send(to, content);
    }
}

새 작업 도착
    ↓
[corePoolSize(5) 이하?]
    ├─ Yes → 새 스레드 생성하여 즉시 실행
    └─ No
        ↓
    [큐(50)에 공간 있음?]
        ├─ Yes → 큐에 추가하여 대기
        └─ No
            ↓
        [maxPoolSize(10) 이하?]
            ├─ Yes → 추가 스레드 생성하여 실행
            └─ No → RejectedExecutionHandler 호출

// 방법 1: CompletableFuture로 예외 전달
@Async
public CompletableFuture<Result> asyncWithException() {
    try {
        Result result = riskyOperation();
        return CompletableFuture.completedFuture(result);
    } catch (Exception e) {
        return CompletableFuture.failedFuture(e);
    }
}

// 호출부
asyncService.asyncWithException()
    .thenAccept(result -> log.info("성공: {}", result))
    .exceptionally(e -> {
        log.error("비동기 작업 실패: ", e);
        return null;
    });

// 방법 2: AsyncUncaughtExceptionHandler 전역 설정
@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return (throwable, method, params) -> {
            log.error("비동기 메서드 [{}] 예외: {}",
                method.getName(), throwable.getMessage(), throwable);
            // 알림 발송 등
        };
    }
}

@Service
public class MyService {

    public void caller() {
        this.asyncMethod();  // @Async 동작하지 않음! (프록시 우회)
    }

    @Async
    public void asyncMethod() {
        // 동기로 실행됨
    }
}

// 해결: 별도 빈으로 분리
@Service
public class CallerService {
    @Autowired private AsyncService asyncService;

    public void caller() {
        asyncService.asyncMethod();  // 정상 동작
    }
}

@Transactional
@Async  // 주의: 별도 스레드에서 실행되므로 기존 트랜잭션에 참여하지 않음
public void asyncTransactional() {
    // 새로운 트랜잭션이 시작됨
}

# Spring Boot 3.2+
spring:
  threads:
    virtual:
      enabled: true  # Tomcat, @Async 모두 Virtual Threads 사용

플랫폼 스레드: ~1MB 메모리 × 200개 = ~200MB
가상 스레드: ~1KB 메모리 × 100,000개 = ~100MB

// 1. synchronized 블록에서 OS 스레드를 점유(pinning)
synchronized (lock) {
    // 이 안에서 블로킹 I/O를 하면 Virtual Thread의 이점이 사라짐
    // ReentrantLock으로 대체
}

// 2. CPU 바운드 작업에는 이점이 없음
// 가상 스레드는 I/O 대기가 많은 작업에 최적화

// 3. ThreadLocal 남용 주의
// 수십만 가상 스레드 × ThreadLocal 데이터 = 메모리 문제

// Micrometer로 스레드 풀 메트릭 노출
@Bean
public TaskExecutor monitoredExecutor(MeterRegistry registry) {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(10);
    executor.setMaxPoolSize(20);
    executor.setQueueCapacity(100);
    executor.setThreadNamePrefix("monitored-");
    executor.initialize();

    // 메트릭 등록
    ExecutorServiceMetrics.monitor(
        registry,
        executor.getThreadPoolExecutor(),
        "async-executor"
    );

    return executor;
}