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

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.