How Virtual Threads Boost Spring Boot 3 Performance: Real-World Benchmarks

Environment

Spring Boot 3.2.5 + JDK 21

1. Introduction

JDK 21 introduces virtual threads; Spring Boot 3.2.x supports them for asynchronous tasks and requests. This article compares platform threads and virtual threads using JMeter to evaluate performance.

2. Practical Cases

2.1 Simulated Time‑Consuming Operation

A controller method returns a Callable that sleeps for two seconds.

// Spring MVC controller using Callable
@GetMapping("/platform")
public Callable<Object> platform() {
    System.out.printf("Request start: %d%n", System.currentTimeMillis());
    Callable<Object> callable = () -> {
        System.out.printf("Current thread: %s%n", Thread.currentThread().getName());
        TimeUnit.SECONDS.sleep(2);
        return "Callable task completed";
    };
    System.out.printf("Request end: %d%n", System.currentTimeMillis());
    return callable;
}

Browser test shows the Tomcat thread finishes instantly while the Callable runs on another thread.

Performance Test Setup

All tests use JVM options -Xms1g -Xmx1g and JMeter with 500 concurrent users, 10 loops, targeting the above endpoint.

Platform thread (default pool, core size 8) shows many timeouts and low throughput.

Increasing the task executor core size to 200 improves throughput but competes with Tomcat threads for CPU and memory.

Virtual Thread Configuration

Enable virtual threads with:

spring:
  threads:
    virtual:
      enabled: true

Spring MVC async uses a bean named applicationTaskExecutor. With virtual threads enabled and no custom pool, throughput rises dramatically:

Remote call example:

@GetMapping("/http")
public Callable<Object> http() {
    System.out.printf("Request start: %d%n", System.currentTimeMillis());
    Callable<Object> callable = () -> {
        System.out.printf("Current thread: %s%n", Thread.currentThread().getName());
        return new RestTemplate().getForObject("http://localhost:8088/demos/rr", String.class);
    };
    System.out.printf("Request end: %d%n", System.currentTimeMillis());
    return callable;
}

2.2 Database‑Based Test

Repository for counting rows:

public interface BigTableRepository extends JpaRepository<BigTable, Integer> {
    // Count total rows
    @Query("select count(name) from BigTable e")
    long count();
}

Data source configured with HikariCP (minimumIdle 200, maximumPoolSize 200):

spring:
  datasource:
    driverClassName: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/batch?serverTimezone=GMT%2B8&useSSL=false
    username: root
    password: xxxooo
    type: com.zaxxer.hikari.HikariDataSource
    hikari:
      minimumIdle: 200
      maximumPoolSize: 200

Platform thread tests with core sizes 8, 100, 200 show little change in overall throughput.

Virtual thread test shows a significant drop in throughput.

Virtual threads can dramatically increase application throughput when the workload involves thousands of concurrent tasks that spend most of their time waiting, rather than being CPU‑bound.

Additional Virtual Thread Tuning

Limit concurrency with:

spring:
  task:
    execution:
      simple:
        concurrency-limit: 100

Default limit is -1 (no limit).

Conclusion: Virtual threads provide higher throughput for I/O‑bound asynchronous requests, but well‑tuned platform thread pools may still be competitive, especially for database‑heavy workloads.