Forget Async/Await: How Java 21 Virtual Threads Change Scalability Forever (The End of the Thread-per-Request Model)

1. The Old Problem: "Platform Threads" are Expensive

• Heavyweight: Each thread consumes ~2MB of memory.
• Limited: You can only spawn ~5,000 to 10,000 threads before your server runs out of RAM.
• Blocking: If a thread makes a Database call (taking 200ms), that OS thread sits idle for 200ms, doing nothing but holding memory.

2. The Solution: Virtual Threads (M:N Model)

• Featherweight: They consume mere bytes, not megabytes.
• Unlimited: You can spawn 1 Million+ virtual threads on a standard laptop.
• Non-Blocking (Magical): When a Virtual Thread makes a database call, the JVM detects it. It unmounts the virtual thread from the carrier OS thread. The OS thread is instantly free to handle another request.

3. The "1 Million Thread" Benchmark

The "Old Way" (Crashes instantly)

  Copy Code 
// DO NOT RUN THIS IN PRODUCTION
// This uses Platform Threads (OS Threads)
public class OldThreads {
    public static void main(String[] args) {
        for (int i = 0; i < 1_000_000; i++) {
            new Thread(() -> {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
} ```

The "New Way" (Runs Smoothly)

  Copy Code 
// Java 21+ Virtual Threads
public class NewVirtualThreads {
    public static void main(String[] args) {
        // Use try-with-resources to manage the executor
        // newVirtualThreadPerTaskExecutor creates a virtual thread for every task
        try (var executor = java.util.concurrent.Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 1_000_000; i++) {
                executor.submit(() -> {
                    try {
                        Thread.sleep(1000); // This does NOT block OS threads anymore!
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
            }
        } // Executor waits for all tasks to complete here
        
        System.out.println("Finished running 1 million threads!");
    }
}

4. How to Enable in Spring Boot 3

  Copy Code 
spring.threads.virtual.enabled=true

1. Request comes in.
2. Assigned to OS Thread #1.
3. Database call (Wait 200ms). OS Thread #1 is blocked.
4. Total Capacity: ~200 concurrent users.

1. Request comes in.
2. Assigned to Virtual Thread A.
3. Database call. Virtual Thread A is "parked". OS Thread is FREE.
4. OS Thread picks up next request.
5. Total Capacity: Limited only by Database connections, not Threads.

5. When NOT to use Virtual Threads?

• REST API calls
• Database queries
• Reading files
• Microservices communication