virtualThread 성능 테스트

// async configuration

@EnableAsync
@Configuration
public class AsyncConfig {

    @Bean(name = "threadPoolTaskExecutor")
    public Executor threadPoolTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(50);
        executor.setMaxPoolSize(100);
        executor.setQueueCapacity(1000);
        executor.setThreadNamePrefix("Async-Thread-");
        executor.initialize();
        return executor;
    }

    @Bean(name = "virtualThreadPoolTaskExecutor")
    public Executor virtualThreadPoolTaskExecutor() {
        SimpleAsyncTaskExecutor executor = new SimpleAsyncTaskExecutor();
        executor.setVirtualThreads(true);
        executor.setThreadNamePrefix("V-Thread-");
        return executor;
    }
}

// controller


@RestController
public class AsyncExampleController {

    private static final Logger log = LoggerFactory.getLogger(AsyncExampleController.class);
    @Autowired
    private AsyncExampleService asyncExampleService;

    @GetMapping("/run/cpu")
    public void runCpuExample() throws ExecutionException, InterruptedException {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        // 1000개의 비동기 작업 실행
        List<CompletableFuture<String>> futures = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            futures.add(asyncExampleService.executeCpuTask(i));
        }

        // 모든 작업이 완료될 때까지 대기
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
        stopWatch.stop();
        log.info("All tasks finished in {} ms",  stopWatch.getTotalTimeMillis());
    }

    @GetMapping("/run/io")
    public void runIoExample() throws ExecutionException, InterruptedException {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        // 1000개의 비동기 작업 실행
        List<CompletableFuture<String>> futures = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            futures.add(asyncExampleService.executeIoTask(i));
        }

        // 모든 작업이 완료될 때까지 대기
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
        stopWatch.stop();
        log.info("All tasks finished in {} ms",  stopWatch.getTotalTimeMillis());
    }
}

// service

@Slf4j
@Service
public class AsyncExampleService {

    private static final Logger log = LoggerFactory.getLogger(AsyncExampleService.class);

//    @Async("threadPoolTaskExecutor")
    @Async("virtualThreadPoolTaskExecutor")
    public CompletableFuture<String> executeCpuTask(int taskId) {
        log.info("Task {} : start", taskId);
        calculatePrimes(1, 1000000);
        log.info("Task {} : completed", taskId);

        return CompletableFuture.completedFuture("Task " + taskId + " finished");
    }

    // 주어진 범위 내에서 소수 개수 계산
    private int calculatePrimes(int start, int end) {
        int count = 0;
        for (int i = start; i <= end; i++) {
            if (isPrime(i)) {
                count++;
            }
        }
        return count;
    }

    // 소수 판별 함수
    private boolean isPrime(int number) {
        if (number <= 1) return false;
        for (int i = 2; i <= Math.sqrt(number); i++) {
            if (number % i == 0) {
                return false;
            }
        }
        return true;
    }

//    @Async("threadPoolTaskExecutor")
    @Async("virtualThreadPoolTaskExecutor")
    public CompletableFuture<String> executeIoTask(int taskId) {
        log.info("Task {} : start", taskId);
        long result = readFile();
        log.info("Task {} : completed ({})", taskId, result);

        return CompletableFuture.completedFuture("Task " + taskId + " finished");
    }

    private long readFile(){
        long sum = 0;
        ClassPathResource resource = new ClassPathResource("sample/exampleTest.txt");
        try(BufferedReader br = new BufferedReader(new InputStreamReader(resource.getInputStream()))){
            String s = "";
            while((s = br.readLine()) != null){
                String countStr = StringUtils.split(s, "exampleTest-")[1];
                sum += Long.valueOf(countStr);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return sum;
    }

}