Virtual Threads (Java 21+) in Microservices

Java 21 introduces Virtual Threads, a lightweight concurrency model that allows running thousands—or even millions—of concurrent tasks efficiently, without the overhead of traditional OS threads. This is a major shift for high-throughput microservices, simplifying thread management while maintaining performance.

What Are Virtual Threads?

Virtual Threads, introduced in Java 21 via Project Loom, are lightweight threads managed by the JVM rather than the operating system. Unlike traditional OS threads, virtual threads are extremely cheap to create and allow applications to handle millions of concurrent tasks with minimal memory usage.

Key Features:

Lightweight: Each virtual thread uses ~1KB of memory compared to ~1MB for a traditional thread.
Non-blocking: Blocking operations do not block underlying OS threads.
Scalable: Ideal for high-concurrency, I/O-bound microservices.
JVM-managed: Simplifies thread scheduling and lifecycle management.

Platform Threads vs Virtual Threads

Feature	Platform (OS) Thread	Virtual Thread
Creation Cost	High (~1MB stack)	Very low (~1KB stack)
Blocking	Expensive, blocks OS thread	Cheap, doesn’t block OS thread
Ideal For	CPU-bound tasks	I/O-bound tasks
Scalability	Hundreds to thousands	Hundreds of thousands+

Why Microservices Need Virtual Threads

Microservices often make multiple I/O-bound calls per request, such as:

Database queries
REST API calls to other services
File or external API operations

Traditional threads:

One OS thread per request
Blocks on I/O
High memory usage
Limited scalability

Virtual threads:

Each request runs in its own virtual thread
Blocking operations don’t block OS threads
Can handle thousands of concurrent requests efficiently

Creating Virtual Threads

Single virtual thread:

Creates a lightweight thread managed by the JVM.
Ideal for simple, one-off tasks.

Thread vt = Thread.ofVirtual().start(() -> {
    System.out.println("Running in virtual thread: " + Thread.currentThread());
});
vt.join();

Executor-based (preferred for multiple tasks):

Supports many concurrent tasks efficiently.
Scales automatically with workload — perfect for microservices handling multiple I/O-bound requests.

ExecutorServiceexecutor= Executors.newVirtualThreadPerTaskExecutor();

executor.submit(() -> {
    System.out.println("Processing request in virtual thread: " + Thread.currentThread());
});

executor.shutdown();

Using Virtual Threads in Spring Boot

With Java 21 and Spring Boot, virtual threads can be used in REST controllers, service layers, @Async methods, and CompletableFuture for lightweight, scalable concurrency.

Configure Executor:

Manages tasks using JVM-managed virtual threads.
Handles thousands of concurrent requests with minimal memory overhead.

@Bean(name = "virtualThreadExecutor")
public Executor virtualThreadExecutor() {
    return Executors.newVirtualThreadPerTaskExecutor();
}

Example with @Async:

Runs background tasks asynchronously without blocking OS threads.
Perfect for I/O-heavy operations like API calls or database queries.

@Async("virtualThreadExecutor")
public CompletableFuture<String> fetchData() {
    String data = restTemplate.getForObject("<http://service/api>", String.class);
    return CompletableFuture.completedFuture(data);
}

Example with CompletableFuture:

Executes multiple tasks in parallel efficiently.
Reduces overall API latency compared to sequential calls.

CompletableFuture.supplyAsync(
    () -> restTemplate.getForObject("<http://service/api>", String.class),
    virtualThreadExecutor()
);

Example REST Controller Using Virtual Threads:

Each HTTP request runs in a virtual thread.
Efficiently handles thousands of concurrent requests.
Ideal for modern microservices with multiple I/O-bound calls.

@RestController
public class OrderController {
    private final OrderService orderService;

    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }

    @GetMapping("/order/{id}")
    public CompletableFuture<Order> getOrder(@PathVariable Long id) {
        return CompletableFuture.supplyAsync(
            () -> orderService.getOrder(id),
            Executors.newVirtualThreadPerTaskExecutor()
        );
    }
}

Benefits for Microservices

Write synchronous-style code without performance penalty
Handle hundreds of thousands of concurrent I/O requests
Reduce memory and CPU usage compared to traditional threads
Seamlessly integrates with Spring Boot, JDBC, RestTemplate, @Async, and CompletableFuture
Eliminates the need for complex thread pools

Performance Implications

High concurrency without memory explosion
Reduced thread context switching
Simplified programming model — code remains readable and maintainable
Perfect for I/O-heavy microservices or API aggregation services

Best Practices

Use virtual threads only for I/O-bound tasks, not CPU-intensive workloads
Combine with structured concurrency for better lifecycle management
Profile JVM memory and CPU usage under high concurrency
Ensure sufficient database connection pool size
Monitor threads even though virtual threads are lightweight

Real-World Use Case: Microservice API Aggregator

Scenario: Aggregating user info, payment info, and inventory info for an order summary in a microservices architecture.

Flow:

Client → API Gateway → Virtual Thread per Request → Multiple I/O Calls → Response

Each downstream call is I/O-bound (HTTP, DB).
Virtual threads allow one thread per request → massive scalability.
No blocked OS threads → easier management and simpler code compared to reactive frameworks.

Conclusion

Virtual Threads introduced in Java 21 transform how microservices handle concurrency:

Write synchronous-style code that scales effortlessly.
Handle hundreds of thousands of concurrent I/O requests with minimal resources.
Integrates smoothly with Spring Boot, CompletableFuture, and @Async.
Reduces memory usage, context switching, and the complexity of managing traditional thread pools.
Ideal for API aggregation, dashboards, and high-traffic microservices requiring low-latency responses.