Java 21 introduced Virtual Threads (formerly known as Project Loom fibers) as a lightweight alternative to platform threads, enabling massive concurrency with minimal resource overhead.

1. Virtual Threads Overview

What are Virtual Threads?

• Lightweight threads managed by the JVM
• Not OS threads - mapped to carrier threads
• Very cheap to create (millions possible)
• Automatic scheduling by JVM
• Seamless integration with existing code

Traditional vs Virtual Threads

public class VirtualThreadsOverview { public static void main(String[] args) throws Exception { demonstrateThreadComparison(); showVirtualThreadBenefits(); } public static void demonstrateThreadComparison() { System.out.println("=== Traditional vs Virtual Threads ==="); System.out.println(""" Traditional Platform Threads: - 1:1 mapping to OS threads - Expensive to create (~1MB stack each) - Limited by OS thread limits (~1000-10000) - Blocking operations block OS threads Virtual Threads: - M:N mapping to carrier threads - Cheap to create (~200 bytes each) - Can create millions of virtual threads - Blocking doesn't block carrier threads - Automatic scheduling by JVM """); } public static void showVirtualThreadBenefits() { System.out.println("=== Virtual Thread Benefits ==="); System.out.println(""" Key Advantages: Performance: - Massive concurrency with minimal memory - No context switching overhead - Better CPU utilization Simplicity: - Same programming model as platform threads - Works with existing synchronized blocks - Compatible with java.util.concurrent Scalability: - Handle millions of concurrent operations - Perfect for I/O-bound workloads - Better resource utilization """); } }

2. Creating and Using Virtual Threads

Basic Virtual Thread Creation

import java.time.Duration; import java.util.concurrent.Executors; import java.util.stream.IntStream; public class BasicVirtualThreads { public static void main(String[] args) throws Exception { demonstrateThreadCreation(); demonstrateMassiveConcurrency(); demonstrateExecutorService(); } public static void demonstrateThreadCreation() throws InterruptedException { System.out.println("=== Virtual Thread Creation ==="); // Method 1: Using Thread.ofVirtual() Thread virtualThread1 = Thread.ofVirtual() .name("virtual-thread-1") .start(() -> { System.out.println("Hello from virtual thread: " + Thread.currentThread()); try { Thread.sleep(1000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); // Method 2: Using Thread.startVirtualThread() Thread virtualThread2 = Thread.startVirtualThread(() -> { System.out.println("Hello from virtual thread: " + Thread.currentThread()); try { Thread.sleep(1000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); // Method 3: Using builder Thread.Builder virtualThreadBuilder = Thread.ofVirtual().name("worker-", 0); Thread virtualThread3 = virtualThreadBuilder.start(() -> { System.out.println("Hello from virtual thread: " + Thread.currentThread()); }); virtualThread1.join(); virtualThread2.join(); virtualThread3.join(); System.out.println("All virtual threads completed"); } public static void demonstrateMassiveConcurrency() throws InterruptedException { System.out.println("\n=== Massive Concurrency Demonstration ==="); int numberOfThreads = 100_000; System.out.println("Creating " + numberOfThreads + " virtual threads..."); long startTime = System.nanoTime(); var threads = IntStream.range(0, numberOfThreads) .mapToObj(i -> Thread.ofVirtual() .name("virtual-thread-", i) .start(() -> { try { // Simulate some work Thread.sleep(100); if (i % 10_000 == 0) { System.out.println("Thread " + i + " completed"); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } })) .toList(); // Wait for all threads to complete for (Thread thread : threads) { thread.join(); } long endTime = System.nanoTime(); long duration = (endTime - startTime) / 1_000_000; System.out.printf("Completed %d virtual threads in %d ms%n", numberOfThreads, duration); System.out.println("Memory used: " + (Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) / 1024 / 1024 + " MB"); } public static void demonstrateExecutorService() throws InterruptedException { System.out.println("\n=== Virtual Thread Executor Service ==="); try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { // Submit multiple tasks var future1 = executor.submit(() -> { System.out.println("Task 1 running in: " + Thread.currentThread()); Thread.sleep(500); return "Result 1"; }); var future2 = executor.submit(() -> { System.out.println("Task 2 running in: " + Thread.currentThread()); Thread.sleep(300); return "Result 2"; }); var future3 = executor.submit(() -> { System.out.println("Task 3 running in: " + Thread.currentThread()); Thread.sleep(700); return "Result 3"; }); // Get results System.out.println("Future 1: " + future1.get()); System.out.println("Future 2: " + future2.get()); System.out.println("Future 3: " + future3.get()); } catch (Exception e) { e.printStackTrace(); } System.out.println("Executor service completed"); } public static void demonstrateThreadProperties() { System.out.println("\n=== Virtual Thread Properties ==="); Thread virtualThread = Thread.ofVirtual() .name("demo-virtual-thread") .start(() -> { Thread current = Thread.currentThread(); System.out.println("Thread name: " + current.getName()); System.out.println("Is virtual: " + current.isVirtual()); System.out.println("Thread ID: " + current.threadId()); System.out.println("Priority: " + current.getPriority()); System.out.println("Is daemon: " + current.isDaemon()); System.out.println("Thread group: " + current.getThreadGroup()); System.out.println("State: " + current.getState()); }); try { virtualThread.join(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } }

3. Real-World Use Cases

High-Concurrency Web Server

import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; import java.util.concurrent.Executors; public class VirtualThreadWebServer { private static final int PORT = 8080; private static final int MAX_REQUESTS = 10_000; public static void main(String[] args) throws IOException { demonstrateWebServer(); } public static void demonstrateWebServer() throws IOException { System.out.println("=== Virtual Thread Web Server Demo ==="); try (var executor = Executors.newVirtualThreadPerTaskExecutor(); var serverSocket = new ServerSocket(PORT)) { System.out.println("Server listening on port " + PORT); System.out.println("Using virtual threads for request handling"); int requestCount = 0; while (requestCount < MAX_REQUESTS) { Socket clientSocket = serverSocket.accept(); requestCount++; executor.submit(() -> handleRequest(clientSocket, requestCount)); if (requestCount % 1000 == 0) { System.out.println("Processed " + requestCount + " requests"); } } } System.out.println("Server shutdown completed"); } private static void handleRequest(Socket clientSocket, int requestId) { try (clientSocket) { // Simulate request processing Thread.sleep(50); // I/O operation simulation // Simulate different types of requests String response = switch (requestId % 4) { case 0 -> processUserProfile(requestId); case 1 -> processOrder(requestId); case 2 -> processPayment(requestId); case 3 -> processSearch(requestId); default -> "Unknown request"; }; if (requestId % 500 == 0) { System.out.println("Request " + requestId + " processed: " + response); } } catch (IOException | InterruptedException e) { System.err.println("Error handling request " + requestId + ": " + e.getMessage()); Thread.currentThread().interrupt(); } } private static String processUserProfile(int requestId) throws InterruptedException { Thread.sleep(10); // Database query simulation return "User profile for request " + requestId; } private static String processOrder(int requestId) throws InterruptedException { Thread.sleep(20); // Order processing simulation return "Order processed for request " + requestId; } private static String processPayment(int requestId) throws InterruptedException { Thread.sleep(15); // Payment gateway simulation return "Payment completed for request " + requestId; } private static String processSearch(int requestId) throws InterruptedException { Thread.sleep(25); // Search index simulation return "Search results for request " + requestId; } } // Database connection pool simulation with virtual threads class DatabaseService { private static final int CONNECTION_POOL_SIZE = 20; public String queryUserData(int userId) throws InterruptedException { // Simulate database query Thread.sleep(10); return "User data for ID: " + userId; } public void processWithVirtualThreads() throws InterruptedException { try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { // Process 1000 database queries concurrently for (int i = 1; i <= 1000; i++) { final int userId = i; executor.submit(() -> { try { String result = queryUserData(userId); if (userId % 100 == 0) { System.out.println("Processed user " + userId + ": " + result); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); } } } }

I/O Intensive Operations

import java.net.URI; import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; import java.util.ArrayList; import java.util.List; import java.util.concurrent.CompletableFuture; import java.util.concurrent.Executors; import java.util.concurrent.atomic.AtomicInteger; public class IOIntensiveOperations { public static void main(String[] args) throws Exception { demonstrateHttpRequests(); demonstrateFileOperations(); demonstrateDatabaseOperations(); } public static void demonstrateHttpRequests() throws InterruptedException { System.out.println("=== HTTP Requests with Virtual Threads ==="); int numberOfRequests = 100; AtomicInteger completedRequests = new AtomicInteger(); try (var executor = Executors.newVirtualThreadPerTaskExecutor(); var httpClient = HttpClient.newBuilder() .executor(executor) .build()) { List<CompletableFuture<Void>> futures = new ArrayList<>(); for (int i = 1; i <= numberOfRequests; i++) { final int requestId = i; CompletableFuture<Void> future = CompletableFuture.runAsync(() -> { try { // Simulate HTTP request to different endpoints String endpoint = switch (requestId % 4) { case 0 -> "https://httpbin.org/delay/1"; case 1 -> "https://httpbin.org/delay/2"; case 2 -> "https://httpbin.org/status/200"; case 3 -> "https://httpbin.org/bytes/1024"; default -> "https://httpbin.org/get"; }; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(endpoint)) .GET() .build(); // For real HTTP requests (commented to avoid actual network calls) // HttpResponse<String> response = httpClient.send(request, // HttpResponse.BodyHandlers.ofString()); // Simulate network delay instead Thread.sleep(100 + (requestId % 3) * 50); int count = completedRequests.incrementAndGet(); if (count % 10 == 0) { System.out.println("Completed " + count + " HTTP requests"); } } catch (Exception e) { System.err.println("Request " + requestId + " failed: " + e.getMessage()); } }, executor); futures.add(future); } // Wait for all requests to complete CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join(); } System.out.println("All " + completedRequests.get() + " HTTP requests completed"); } public static void demonstrateFileOperations() throws InterruptedException { System.out.println("\n=== File I/O with Virtual Threads ==="); int numberOfFiles = 500; AtomicInteger processedFiles = new AtomicInteger(); try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { List<CompletableFuture<Void>> futures = new ArrayList<>(); for (int i = 1; i <= numberOfFiles; i++) { final int fileId = i; CompletableFuture<Void> future = CompletableFuture.runAsync(() -> { try { // Simulate file operations simulateFileRead(fileId); simulateFileProcess(fileId); simulateFileWrite(fileId); int count = processedFiles.incrementAndGet(); if (count % 50 == 0) { System.out.println("Processed " + count + " files"); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }, executor); futures.add(future); } CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join(); } System.out.println("All " + processedFiles.get() + " file operations completed"); } private static void simulateFileRead(int fileId) throws InterruptedException { Thread.sleep(20); // Simulate disk I/O } private static void simulateFileProcess(int fileId) throws InterruptedException { Thread.sleep(10); // Simulate CPU work } private static void simulateFileWrite(int fileId) throws InterruptedException { Thread.sleep(15); // Simulate disk I/O } public static void demonstrateDatabaseOperations() { System.out.println("\n=== Database Operations with Virtual Threads ==="); DatabaseConnectionPool pool = new DatabaseConnectionPool(10); int numberOfQueries = 1000; long startTime = System.nanoTime(); try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { List<CompletableFuture<String>> futures = new ArrayList<>(); for (int i = 1; i <= numberOfQueries; i++) { final int queryId = i; CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> { try { return pool.executeQuery("SELECT * FROM data WHERE id = " + queryId); } catch (InterruptedException e) { Thread.currentThread().interrupt(); return "Query " + queryId + " interrupted"; } }, executor); futures.add(future); } // Process results as they complete AtomicInteger completed = new AtomicInteger(); futures.forEach(future -> { future.thenAccept(result -> { int count = completed.incrementAndGet(); if (count % 100 == 0) { System.out.println("Completed " + count + " database queries"); } }); }); CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join(); } long endTime = System.nanoTime(); long duration = (endTime - startTime) / 1_000_000; System.out.printf("Completed %d database queries in %d ms%n", numberOfQueries, duration); } } class DatabaseConnectionPool { private final int poolSize; private final AtomicInteger availableConnections; public DatabaseConnectionPool(int poolSize) { this.poolSize = poolSize; this.availableConnections = new AtomicInteger(poolSize); } public String executeQuery(String query) throws InterruptedException { // Simulate getting connection from pool while (availableConnections.get() <= 0) { Thread.sleep(1); // Wait for connection } availableConnections.decrementAndGet(); try { // Simulate database query execution Thread.sleep(5); // Network + database processing return "Result for: " + query; } finally { availableConnections.incrementAndGet(); } } }

4. Advanced Virtual Thread Features

Pinned Virtual Threads and Monitoring

import java.lang.management.ManagementFactory; import java.lang.management.ThreadMXBean; import java.util.concurrent.Executors; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class AdvancedVirtualThreads { public static void main(String[] args) throws Exception { demonstratePinnedThreads(); demonstrateThreadLocalUsage(); demonstrateMonitoring(); demonstrateStructuredConcurrency(); } public static void demonstratePinnedThreads() throws InterruptedException { System.out.println("=== Pinned Virtual Threads ==="); // Virtual threads can get "pinned" to carrier threads in certain situations Object monitor = new Object(); try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { for (int i = 0; i < 5; i++) { final int taskId = i; executor.submit(() -> { System.out.println("Task " + taskId + " started in: " + Thread.currentThread()); // Synchronized block - can cause pinning synchronized (monitor) { try { System.out.println("Task " + taskId + " in synchronized block, thread: " + Thread.currentThread()); Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } System.out.println("Task " + taskId + " completed"); }); } } System.out.println("\nUsing ReentrantLock instead of synchronized:"); Lock lock = new ReentrantLock(); try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { for (int i = 0; i < 5; i++) { final int taskId = i; executor.submit(() -> { System.out.println("Task " + taskId + " started in: " + Thread.currentThread()); // Using Lock instead of synchronized - no pinning lock.lock(); try { System.out.println("Task " + taskId + " in locked section, thread: " + Thread.currentThread()); Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { lock.unlock(); } System.out.println("Task " + taskId + " completed"); }); } } } public static void demonstrateThreadLocalUsage() throws InterruptedException { System.out.println("\n=== ThreadLocal with Virtual Threads ==="); ThreadLocal<String> userContext = new ThreadLocal<>(); InheritableThreadLocal<String> inheritableContext = new InheritableThreadLocal<>(); try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { for (int i = 0; i < 5; i++) { final int userId = i; executor.submit(() -> { // Set thread-local values userContext.set("User-" + userId); inheritableContext.set("Inheritable-User-" + userId); System.out.println("ThreadLocal: " + userContext.get()); System.out.println("InheritableThreadLocal: " + inheritableContext.get()); // Simulate work try { Thread.sleep(50); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } // Clean up (important for virtual threads!) userContext.remove(); inheritableContext.remove(); }); } } System.out.println("Note: ThreadLocal values should be cleaned up to prevent memory leaks"); } public static void demonstrateMonitoring() throws InterruptedException { System.out.println("\n=== Virtual Thread Monitoring ==="); ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean(); System.out.println("Current thread count: " + threadMXBean.getThreadCount()); System.out.println("Peak thread count: " + threadMXBean.getPeakThreadCount()); // Create some virtual threads and monitor try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { for (int i = 0; i < 100; i++) { executor.submit(() -> { try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); } // Give threads time to start Thread.sleep(50); System.out.println("Thread count after creating virtual threads: " + threadMXBean.getThreadCount()); } System.out.println("Thread count after executor closed: " + threadMXBean.getThreadCount()); } public static void demonstrateStructuredConcurrency() throws InterruptedException { System.out.println("\n=== Structured Concurrency with Virtual Threads ==="); // Using ExecutorService automatically provides structured concurrency try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { var userFuture = executor.submit(() -> { System.out.println("Fetching user data..."); Thread.sleep(100); return "User Data"; }); var orderFuture = executor.submit(() -> { System.out.println("Fetching order history..."); Thread.sleep(150); return "Order History"; }); var paymentFuture = executor.submit(() -> { System.out.println("Fetching payment info..."); Thread.sleep(80); return "Payment Info"; }); try { String userData = userFuture.get(); String orderHistory = orderFuture.get(); String paymentInfo = paymentFuture.get(); System.out.println("Combined result:"); System.out.println(" - " + userData); System.out.println(" - " + orderHistory); System.out.println(" - " + paymentInfo); } catch (Exception e) { System.err.println("Error fetching data: " + e.getMessage()); // All tasks are automatically cancelled if any fail } } System.out.println("All tasks completed within structured scope"); } }

5. Performance Comparison

Virtual Threads vs Platform Threads Benchmark

import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicInteger; import java.util.stream.IntStream; public class VirtualThreadsBenchmark { private static final int TASK_COUNT = 10_000; private static final int IO_DELAY_MS = 100; public static void main(String[] args) throws Exception { runPlatformThreadsBenchmark(); runVirtualThreadsBenchmark(); runMixedWorkloadBenchmark(); } public static void runPlatformThreadsBenchmark() throws InterruptedException { System.out.println("=== Platform Threads Benchmark ==="); long startTime = System.nanoTime(); long memoryBefore = getUsedMemory(); try (var executor = Executors.newFixedThreadPool(200)) { // Limited to 200 threads due to platform thread constraints AtomicInteger completed = new AtomicInteger(); CountDownLatch latch = new CountDownLatch(TASK_COUNT); for (int i = 0; i < TASK_COUNT; i++) { final int taskId = i; executor.submit(() -> { try { // Simulate I/O operation Thread.sleep(IO_DELAY_MS); int count = completed.incrementAndGet(); if (count % 1000 == 0) { System.out.println("Platform threads completed: " + count); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { latch.countDown(); } }); } latch.await(); } long endTime = System.nanoTime(); long duration = (endTime - startTime) / 1_000_000; long memoryUsed = getUsedMemory() - memoryBefore; System.out.printf("Platform threads: %d tasks in %d ms, memory: %d KB%n", TASK_COUNT, duration, memoryUsed / 1024); } public static void runVirtualThreadsBenchmark() throws InterruptedException { System.out.println("\n=== Virtual Threads Benchmark ==="); long startTime = System.nanoTime(); long memoryBefore = getUsedMemory(); try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { // Can handle all 10,000 tasks concurrently AtomicInteger completed = new AtomicInteger(); CountDownLatch latch = new CountDownLatch(TASK_COUNT); for (int i = 0; i < TASK_COUNT; i++) { final int taskId = i; executor.submit(() -> { try { // Simulate I/O operation Thread.sleep(IO_DELAY_MS); int count = completed.incrementAndGet(); if (count % 1000 == 0) { System.out.println("Virtual threads completed: " + count); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { latch.countDown(); } }); } latch.await(); } long endTime = System.nanoTime(); long duration = (endTime - startTime) / 1_000_000; long memoryUsed = getUsedMemory() - memoryBefore; System.out.printf("Virtual threads: %d tasks in %d ms, memory: %d KB%n", TASK_COUNT, duration, memoryUsed / 1024); } public static void runMixedWorkloadBenchmark() throws InterruptedException { System.out.println("\n=== Mixed Workload Benchmark ==="); int[] workloads = {100, 1000, 5000, 10000}; for (int workload : workloads) { System.out.println("\nWorkload: " + workload + " tasks"); // Platform threads long platformTime = benchmarkPlatformThreads(workload); long virtualTime = benchmarkVirtualThreads(workload); System.out.printf("Platform: %d ms, Virtual: %d ms, Speedup: %.2fx%n", platformTime, virtualTime, (double) platformTime / virtualTime); } } private static long benchmarkPlatformThreads(int taskCount) throws InterruptedException { int threadPoolSize = Math.min(taskCount, 200); long startTime = System.nanoTime(); try (var executor = Executors.newFixedThreadPool(threadPoolSize)) { CountDownLatch latch = new CountDownLatch(taskCount); for (int i = 0; i < taskCount; i++) { executor.submit(() -> { try { Thread.sleep(IO_DELAY_MS); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { latch.countDown(); } }); } latch.await(); } return (System.nanoTime() - startTime) / 1_000_000; } private static long benchmarkVirtualThreads(int taskCount) throws InterruptedException { long startTime = System.nanoTime(); try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { CountDownLatch latch = new CountDownLatch(taskCount); for (int i = 0; i < taskCount; i++) { executor.submit(() -> { try { Thread.sleep(IO_DELAY_MS); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { latch.countDown(); } }); } latch.await(); } return (System.nanoTime() - startTime) / 1_000_000; } private static long getUsedMemory() { Runtime runtime = Runtime.getRuntime(); return runtime.totalMemory() - runtime.freeMemory(); } public static void demonstrateCPUvsIO() throws InterruptedException { System.out.println("\n=== CPU-bound vs I/O-bound Workloads ==="); System.out.println(""" Virtual Threads Performance Characteristics: I/O-bound workloads: - Excellent performance - Massive concurrency - Minimal memory overhead - Perfect for web servers, databases, network calls CPU-bound workloads: - Similar performance to platform threads - No significant advantage - Still useful for mixed workloads Best used for: - HTTP servers/clients - Database operations - File I/O - Message queues - Any blocking I/O operations """); } }

6. Best Practices and Migration

Virtual Threads Best Practices

import java.util.concurrent.*; public class VirtualThreadsBestPractices { public static void main(String[] args) { demonstrateBestPractices(); demonstrateMigrationStrategies(); demonstrateAntiPatterns(); } public static void demonstrateBestPractices() { System.out.println("=== Virtual Threads Best Practices ==="); System.out.println(""" ✅ DO: 1. Use for I/O-bound workloads - HTTP requests, database calls, file operations 2. Use Executors.newVirtualThreadPerTaskExecutor() - Automatic resource management - Structured concurrency 3. Clean up ThreadLocal variables - Call remove() to prevent memory leaks 4. Use locks instead of synchronized - Avoids carrier thread pinning 5. Monitor thread creation - Use JVM metrics for monitoring 6. Handle exceptions properly - Virtual threads behave like platform threads Configuration: - Use default settings for most cases - Adjust -XX:VirtualThreadSchedulerParallelism for CPU-bound mix - Monitor with JDK flight recorder """); } public static void demonstrateMigrationStrategies() throws InterruptedException { System.out.println("\n=== Migration Strategies ==="); // Before migration - platform threads ExecutorService oldExecutor = Executors.newFixedThreadPool(100); // After migration - virtual threads ExecutorService newExecutor = Executors.newVirtualThreadPerTaskExecutor(); System.out.println("Migration example:"); System.out.println(" Before: Executors.newFixedThreadPool(100)"); System.out.println(" After: Executors.newVirtualThreadPerTaskExecutor()"); // Same task submission code works for both Runnable task = () -> { try { Thread.sleep(100); System.out.println("Task executed in: " + Thread.currentThread()); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }; oldExecutor.submit(task); newExecutor.submit(task); oldExecutor.shutdown(); newExecutor.shutdown(); oldExecutor.awaitTermination(1, TimeUnit.SECONDS); newExecutor.awaitTermination(1, TimeUnit.SECONDS); System.out.println("Same code works with both executors!"); } public static void demonstrateAntiPatterns() { System.out.println("\n=== Virtual Threads Anti-Patterns ==="); System.out.println(""" ❌ DON'T: 1. Use for CPU-bound workloads only - No benefit over platform threads - May even have slight overhead 2. Create unlimited virtual threads for CPU work - Can still overwhelm the system - Use bounded executors for CPU work 3. Forget to clean up resources - ThreadLocal, socket connections, file handles 4. Use synchronized with long operations - Causes carrier thread pinning - Use ReentrantLock instead 5. Assume all blocking is magically cheap - Underlying I/O operations still have costs - Monitor actual resource usage 6. Ignore exception handling - Virtual threads propagate exceptions like platform threads """); demonstrateCommonMistakes(); } public static void demonstrateCommonMistakes() { System.out.println("\n=== Common Mistakes ==="); // Mistake 1: Not cleaning up ThreadLocal ThreadLocal<String> context = new ThreadLocal<>(); try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { executor.submit(() -> { context.set("some-value"); // Forgot to call context.remove() - memory leak! }); } // Solution: Always clean up try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { executor.submit(() -> { try { context.set("some-value"); // Do work... } finally { context.remove(); // Proper cleanup } }); } // Mistake 2: Using synchronized with long operations Object lock = new Object(); try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { executor.submit(() -> { synchronized (lock) { // This pins the carrier thread! try { Thread.sleep(1000); // Long operation } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } }); } // Solution: Use Lock instead Lock properLock = new ReentrantLock(); try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { executor.submit(() -> { properLock.lock(); try { Thread.sleep(1000); // No pinning! } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { properLock.unlock(); } }); } System.out.println("Avoid these common pitfalls for optimal performance"); } public static void showConfigurationOptions() { System.out.println("\n=== JVM Configuration Options ==="); System.out.println(""" Virtual Threads JVM Options: -XX:+UseVirtualThreads Enable virtual threads (default in future versions) -XX:VirtualThreadSchedulerParallelism=<number> Number of carrier threads (defaults to CPU cores) -XX:VirtualThreadStackSize=<size> Stack size for virtual threads -Xlog:vthread*=debug Enable virtual thread logging Monitoring: - Use JFR (Java Flight Recorder) for detailed metrics - JMX beans for thread count and status - OS monitoring for overall system resources """); } }

Conclusion

Virtual Threads Benefits Summary:

When to Use Virtual Threads:

Migration Strategy:

1. Replace thread pools with Executors.newVirtualThreadPerTaskExecutor()
2. Keep existing code - same APIs work
3. Monitor performance and resource usage
4. Clean up ThreadLocal variables
5. Prefer Lock over synchronized for long operations

Java Version Requirements:

• Java 19: Initial preview
• Java 20: Second preview
• Java 21: Production ready
• Java 22+: Enhanced and optimized

Virtual threads revolutionize Java concurrency by enabling massive scale for I/O-bound applications while maintaining the simple thread-per-request programming model that developers love.