How Java Virtual Threads Supercharge SpringBoot: 200× Faster Than Classic Threads

What Is a Virtual Thread

Virtual threads are a feature added in Java 19 that works like Goroutine in Go, providing lightweight, user‑level threads managed by the JVM instead of the operating system.

Difference Between Virtual and Platform Threads

Virtual threads are "fake" threads that are not scheduled directly by the OS; a single platform thread can multiplex thousands of virtual threads, consuming far less memory and allowing creation of millions of them when resources permit.

Using Virtual Threads in SpringBoot

By configuring SpringBoot 3 to use virtual threads, the default async thread pool and Tomcat HTTP thread pool can be replaced, yielding dramatic performance gains.

@Configuration
@ConditionalOnProperty(prefix = "spring", name = "virtual-thread", havingValue = "true")
public class ThreadConfig {
    @Bean
    public AsyncTaskExecutor applicationTaskExecutor() {
        return new TaskExecutorAdapter(Executors.newVirtualThreadPerTaskExecutor());
    }
    @Bean
    public TomcatProtocolHandlerCustomizer<?> protocolHandlerCustomizer() {
        return protocolHandler -> {
            protocolHandler.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
        };
    }
}

@Async Performance Comparison

An asynchronous service that sleeps for 50 ms (simulating I/O) is invoked 100 000 times.

@Service
public class AsyncService {
    @Async
    public void doSomething(CountDownLatch countDownLatch) throws InterruptedException {
        Thread.sleep(50);
        countDownLatch.countDown();
    }
}

@Test
public void testAsync() throws InterruptedException {
    long start = System.currentTimeMillis();
    int n = 100000;
    CountDownLatch countDownLatch = new CountDownLatch(n);
    for (int i = 0; i < n; i++) {
        asyncService.doSomething(countDownLatch);
    }
    countDownLatch.await();
    long end = System.currentTimeMillis();
    System.out.println("耗时：" + (end - start) + "ms");
}

Results:

Platform thread time: 678 seconds (over 10 minutes)

Virtual thread time:

3.9 seconds

The performance gap is roughly 200×.

HTTP Request Performance Comparison

A simple GET endpoint that sleeps 50 ms is tested with JMeter using 500 concurrent threads and 10 000 requests.

@RequestMapping("/get")
public Object get() throws Exception {
    Thread.sleep(50);
    return "ok";
}

Platform threads: minimum 50 ms, but median and 90/95/99 percentiles exceed 150 ms due to thread pool exhaustion.

Virtual threads: maximum response time stays below 100 ms, showing much lower wait times and better resource utilization.

Conclusion

Virtual threads provide a clear performance advantage for I/O‑bound workloads, such as typical web applications that spend most of their time waiting on database, cache, or network I/O. For CPU‑bound tasks the benefit is smaller, but for the majority of Java web services the gains are substantial.