Java Virtual Threads vs Traditional Threads: What Nobody Tells You

// Creating a virtual thread — Java 21+
Thread vThread = Thread.ofVirtual().start(() -> {
 // This blocks, but doesn't block the carrier thread
 String result = httpClient.send(request, BodyHandlers.ofString()).body();
 System.out.println(result);
});

// Creating with ExecutorService (recommended for production)
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
 Future<String> future = executor.submit(() -> {
 return httpClient.send(request, BodyHandlers.ofString()).body();
 });
 System.out.println(future.get());
}

// One virtual thread per request — the new pattern
// Previously: thread pool of 200 threads = max 200 concurrent requests
// Now: one virtual thread per request, JVM manages carrier threads
// Result: can handle 100,000+ concurrent requests on modest hardware

import java.util.concurrent.*;
import java.net.http.*;

// Test 1: Traditional thread pool — 200 threads, 10,000 requests
ExecutorService pool = Executors.newFixedThreadPool(200);
long start = System.currentTimeMillis();
List<Future<?>> futures = new ArrayList<>();
for (int i = 0; i < 10_000; i++) {
 futures.add(pool.submit(() -> {
 Thread.sleep(100); // Simulate 100ms I/O wait
 return "done";
 }));
}
futures.forEach(f -> f.get());
System.out.println("Thread pool: " + (System.currentTimeMillis() - start) + "ms");
// Typical result: ~5,200ms (10,000 tasks / 200 threads * 100ms)

// Test 2: Virtual threads — unlimited concurrency
ExecutorService vPool = Executors.newVirtualThreadPerTaskExecutor();
start = System.currentTimeMillis();
futures.clear();
for (int i = 0; i < 10_000; i++) {
 futures.add(vPool.submit(() -> {
 Thread.sleep(100); // Same 100ms I/O wait
 return "done";
 }));
}
futures.forEach(f -> f.get());
System.out.println("Virtual threads: " + (System.currentTimeMillis() - start) + "ms");
// Typical result: ~120ms (all 10,000 run concurrently!)

// Speedup for I/O-bound: 43x
// Speedup for CPU-bound: ~0x (virtual threads don't help here)

// ❌ PINNING CASE 1: synchronized block
// Virtual thread CANNOT unmount while inside synchronized
synchronized(lock) {
 httpClient.send(request, handler); // PINNED — blocks carrier thread!
}
// Fix: use ReentrantLock instead of synchronized
ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
 httpClient.send(request, handler); // Can unmount — NOT pinned
} finally {
 lock.unlock();
}

// ❌ PINNING CASE 2: native methods
// JNI calls pin the virtual thread to carrier
// Common culprits: JDBC drivers (many use native code)
// Check your drivers! PostgreSQL JDBC is OK, some Oracle drivers pin

// Detect pinning in your app:
// Run with: -Djdk.tracePinnedThreads=full
// Or programmatically:
System.setProperty("jdk.tracePinnedThreads", "short");

// Spring Boot 3.2+ — enable virtual threads for all request handling
// application.properties:
// spring.threads.virtual.enabled=true

// Or programmatically (Spring Boot 3.2+):
@Configuration
public class VirtualThreadConfig {
 @Bean
 public TomcatProtocolHandlerCustomizer<?> virtualThreadCustomizer() {
 return handler -> handler.setExecutor(
 Executors.newVirtualThreadPerTaskExecutor()
 );
 }
}

// For @Async methods:
@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
 @Override
 public Executor getAsyncExecutor() {
 return Executors.newVirtualThreadPerTaskExecutor();
 }
}

// Result: every HTTP request gets its own virtual thread
// Your service can now handle 10x more concurrent connections
// without changing any business logic

// Before — fixed thread pool (old way)
ExecutorService old = Executors.newFixedThreadPool(200);

// After — virtual threads (one line change)
ExecutorService modern = Executors.newVirtualThreadPerTaskExecutor();

// Check Java version
System.out.println(Runtime.version()); // Need 21+

// Enable preview features for Java 19-20 (not needed for 21+):
// javac --enable-preview --release 21 YourApp.java

// Monitor virtual thread count (should be in thousands for I/O servers):
ThreadMXBean tmx = ManagementFactory.getThreadMXBean();
System.out.println("Platform threads: " + tmx.getThreadCount());
// Virtual thread count needs JFR or custom monitoring