ExecutorService with Virtual Threads in Java

Introduction to Virtual Threads

Virtual Threads (Project Loom), introduced in Java 19 as a preview and finalized in Java 21, are lightweight threads that dramatically reduce the overhead of thread creation and management. They enable highly concurrent applications without the limitations of platform threads.

1. Basic Virtual Threads Usage

Creating Virtual Threads

import java.util.concurrent.*; public class VirtualThreadsBasic { public static void main(String[] args) throws Exception { // Method 1: Using Thread.startVirtualThread() Thread virtualThread = Thread.startVirtualThread(() -> { System.out.println("Hello from virtual thread: " + Thread.currentThread()); }); virtualThread.join(); // Method 2: Using Thread.ofVirtual() Thread.Builder virtualBuilder = Thread.ofVirtual().name("worker-", 0); Thread vt1 = virtualBuilder.start(() -> { System.out.println("Virtual thread 1: " + Thread.currentThread().getName()); }); Thread vt2 = virtualBuilder.start(() -> { System.out.println("Virtual thread 2: " + Thread.currentThread().getName()); }); vt1.join(); vt2.join(); // Method 3: Using Executors.newVirtualThreadPerTaskExecutor() try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { Future<String> future = executor.submit(() -> { Thread.sleep(1000); return "Result from virtual thread"; }); System.out.println("Future result: " + future.get()); } } }

Comparing Platform vs Virtual Threads

import java.util.concurrent.*; import java.util.stream.*; public class ThreadComparison { public static void main(String[] args) throws Exception { int taskCount = 10_000; System.out.println("=== Platform Threads ==="); testWithPlatformThreads(taskCount); System.out.println("\n=== Virtual Threads ==="); testWithVirtualThreads(taskCount); } private static void testWithPlatformThreads(int taskCount) throws Exception { long startTime = System.currentTimeMillis(); try (var executor = Executors.newFixedThreadPool(200)) { var futures = IntStream.range(0, taskCount) .mapToObj(i -> executor.submit(() -> { Thread.sleep(100); // Simulate work return i; })) .toList(); // Wait for all tasks for (var future : futures) { future.get(); } } long duration = System.currentTimeMillis() - startTime; System.out.printf("Completed %d tasks in %d ms%n", taskCount, duration); } private static void testWithVirtualThreads(int taskCount) throws Exception { long startTime = System.currentTimeMillis(); try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { var futures = IntStream.range(0, taskCount) .mapToObj(i -> executor.submit(() -> { Thread.sleep(100); // Simulate work return i; })) .toList(); // Wait for all tasks for (var future : futures) { future.get(); } } long duration = System.currentTimeMillis() - startTime; System.out.printf("Completed %d tasks in %d ms%n", taskCount, duration); } }

2. ExecutorService with Virtual Threads

Basic Virtual Thread Executor

import java.util.concurrent.*; import java.util.*; public class VirtualThreadExecutorBasics { public static void main(String[] args) throws Exception { // 1. Virtual Thread Per Task Executor (most common) try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) { List<Future<String>> futures = new ArrayList<>(); for (int i = 0; i < 10; i++) { final int taskId = i; Future<String> future = executor.submit(() -> { String threadName = Thread.currentThread().getName(); System.out.printf("Task %d executed by %s%n", taskId, threadName); Thread.sleep(1000); // Simulate I/O operation return "Task-" + taskId + "-completed"; }); futures.add(future); } // Collect results for (Future<String> future : futures) { System.out.println("Result: " + future.get()); } } // 2. Custom Virtual Thread Factory ThreadFactory virtualThreadFactory = Thread.ofVirtual().factory(); try (ExecutorService customExecutor = Executors.newThreadPerTaskExecutor(virtualThreadFactory)) { customExecutor.submit(() -> { System.out.println("Custom virtual thread: " + Thread.currentThread()); }); } } }

Advanced Virtual Thread Configuration

import java.util.concurrent.*; import java.util.*; public class AdvancedVirtualThreadExecutor { public static void main(String[] args) throws Exception { // Custom virtual thread factory with configuration ThreadFactory customVirtualThreadFactory = Thread.ofVirtual() .name("custom-vt-", 0) .inheritInheritableThreadLocals(false) // Don't inherit thread locals .factory(); try (ExecutorService executor = Executors.newThreadPerTaskExecutor(customVirtualThreadFactory)) { // Submit multiple tasks List<Callable<String>> tasks = new ArrayList<>(); for (int i = 0; i < 5; i++) { final int taskId = i; tasks.add(() -> { String threadName = Thread.currentThread().getName(); System.out.printf("Task %d on %s%n", taskId, threadName); // Simulate different types of work if (taskId % 2 == 0) { Thread.sleep(500); // I/O bound } else { // CPU-bound work (virtual threads still work, but no benefit) long result = 0; for (int j = 0; j < 1000; j++) { result += j; } } return "Task-" + taskId + "-done"; }); } // Invoke all tasks List<Future<String>> futures = executor.invokeAll(tasks); // Process results for (Future<String> future : futures) { System.out.println("Completed: " + future.get()); } } } }

3. Real-World Use Cases

HTTP Client with Virtual Threads

import java.net.http.*; import java.net.URI; import java.util.concurrent.*; import java.util.*; public class HttpClientVirtualThreads { private final HttpClient httpClient; private final ExecutorService virtualThreadExecutor; public HttpClientVirtualThreads() { this.httpClient = HttpClient.newBuilder() .executor(Executors.newVirtualThreadPerTaskExecutor()) .build(); this.virtualThreadExecutor = Executors.newVirtualThreadPerTaskExecutor(); } public CompletableFuture<String> fetchUrlAsync(String url) { HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(url)) .GET() .build(); return httpClient.sendAsync(request, HttpResponse.BodyHandlers.ofString()) .thenApply(HttpResponse::body); } public List<String> fetchMultipleUrls(List<String> urls) throws Exception { List<Callable<String>> tasks = new ArrayList<>(); for (String url : urls) { tasks.add(() -> { HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(url)) .GET() .build(); HttpResponse<String> response = httpClient.send( request, HttpResponse.BodyHandlers.ofString()); return String.format("URL: %s, Status: %d, Length: %d", url, response.statusCode(), response.body().length()); }); } // Execute all HTTP requests concurrently return virtualThreadExecutor.invokeAll(tasks).stream() .map(future -> { try { return future.get(); } catch (Exception e) { return "Error: " + e.getMessage(); } }) .toList(); } public void shutdown() { virtualThreadExecutor.shutdown(); } public static void main(String[] args) throws Exception { HttpClientVirtualThreads fetcher = new HttpClientVirtualThreads(); List<String> urls = List.of( "https://httpbin.org/delay/1", // Simulates 1-second delay "https://httpbin.org/delay/2", // Simulates 2-second delay "https://httpbin.org/delay/1", "https://httpbin.org/status/200", "https://httpbin.org/status/404" ); long startTime = System.currentTimeMillis(); List<String> results = fetcher.fetchMultipleUrls(urls); long duration = System.currentTimeMillis() - startTime; System.out.printf("Fetched %d URLs in %d ms%n", urls.size(), duration); results.forEach(System.out::println); fetcher.shutdown(); } }

Database Operations with Virtual Threads

import java.sql.*; import java.util.concurrent.*; import java.util.*; import java.util.concurrent.atomic.*; public class DatabaseVirtualThreads { private final ExecutorService virtualThreadExecutor; private final AtomicInteger connectionCounter; public DatabaseVirtualThreads() { this.virtualThreadExecutor = Executors.newVirtualThreadPerTaskExecutor(); this.connectionCounter = new AtomicInteger(0); } // Simulate database connection private Connection getConnection() throws SQLException { // In real application, this would be a real database connection System.out.println("Getting connection: " + connectionCounter.incrementAndGet()); Thread.sleep(100); // Simulate connection overhead return null; // Simplified for example } public CompletableFuture<List<Map<String, Object>>> queryUsersAsync(List<Integer> userIds) { List<CompletableFuture<Map<String, Object>>> futures = userIds.stream() .map(userId -> CompletableFuture.supplyAsync(() -> { try { return queryUserById(userId); } catch (SQLException e) { throw new CompletionException(e); } }, virtualThreadExecutor)) .toList(); return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])) .thenApply(v -> futures.stream() .map(CompletableFuture::join) .toList()); } private Map<String, Object> queryUserById(int userId) throws SQLException { System.out.printf("Querying user %d on virtual thread: %s%n", userId, Thread.currentThread().getName()); // Simulate database I/O Thread.sleep(200); Map<String, Object> user = new HashMap<>(); user.put("id", userId); user.put("name", "User-" + userId); user.put("email", "user" + userId + "@example.com"); user.put("thread", Thread.currentThread().getName()); return user; } public void batchProcessUsers(List<Integer> userIds) throws Exception { List<Callable<String>> tasks = userIds.stream() .map(userId -> (Callable<String>) () -> { try { Map<String, Object> user = queryUserById(userId); // Simulate additional processing Thread.sleep(100); return String.format("Processed user %d: %s", userId, user.get("name")); } catch (Exception e) { return "Failed for user " + userId + ": " + e.getMessage(); } }) .toList(); List<Future<String>> futures = virtualThreadExecutor.invokeAll(tasks); for (Future<String> future : futures) { System.out.println(future.get()); } } public void shutdown() { virtualThreadExecutor.shutdown(); } public static void main(String[] args) throws Exception { DatabaseVirtualThreads processor = new DatabaseVirtualThreads(); // Generate test user IDs List<Integer> userIds = new ArrayList<>(); for (int i = 1; i <= 50; i++) { userIds.add(i); } System.out.println("=== Batch Processing Users ==="); long startTime = System.currentTimeMillis(); processor.batchProcessUsers(userIds); long duration = System.currentTimeMillis() - startTime; System.out.printf("\nProcessed %d users in %d ms%n", userIds.size(), duration); processor.shutdown(); } }

4. Error Handling and Resource Management

Structured Concurrency with Virtual Threads

import java.util.concurrent.*; import java.util.*; public class StructuredConcurrencyVirtualThreads { public static class TaskResult { private final String taskName; private final String result; private final Throwable error; public TaskResult(String taskName, String result, Throwable error) { this.taskName = taskName; this.result = result; this.error = error; } public boolean isSuccess() { return error == null; } public String getTaskName() { return taskName; } public String getResult() { return result; } public Throwable getError() { return error; } } public List<TaskResult> executeTasksWithStructuredConcurrency(List<String> tasks) throws InterruptedException { try (var scope = new StructuredTaskScope.ShutdownOnFailure(); var executor = Executors.newVirtualThreadPerTaskExecutor()) { List<StructuredTaskScope.Subtask<String>> subtasks = new ArrayList<>(); // Submit all tasks for (String task : tasks) { StructuredTaskScope.Subtask<String> subtask = scope.fork(() -> executeTask(task, executor)); subtasks.add(subtask); } try { // Wait for all tasks or first failure scope.join(); scope.throwIfFailed(); // Throws if any task failed } catch (ExecutionException e) { System.out.println("One or more tasks failed: " + e.getMessage()); } // Collect results List<TaskResult> results = new ArrayList<>(); for (StructuredTaskScope.Subtask<String> subtask : subtasks) { if (subtask.state() == StructuredTaskScope.Subtask.State.SUCCESS) { results.add(new TaskResult( "Task", subtask.get(), null )); } else if (subtask.state() == StructuredTaskScope.Subtask.State.FAILED) { results.add(new TaskResult( "Task", null, subtask.exception() )); } } return results; } } private String executeTask(String taskName, ExecutorService executor) { try { // Simulate different types of tasks if (taskName.contains("slow")) { Thread.sleep(2000); } else if (taskName.contains("error")) { throw new RuntimeException("Simulated error for: " + taskName); } else { Thread.sleep(500); } return taskName + "-completed"; } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new RuntimeException("Task interrupted: " + taskName, e); } } public static void main(String[] args) throws Exception { StructuredConcurrencyVirtualThreads executor = new StructuredConcurrencyVirtualThreads(); List<String> tasks = List.of( "fast-task-1", "fast-task-2", "slow-task-1", "error-task", "fast-task-3" ); List<TaskResult> results = executor.executeTasksWithStructuredConcurrency(tasks); System.out.println("\n=== Task Execution Results ==="); for (TaskResult result : results) { if (result.isSuccess()) { System.out.printf("✓ %s: %s%n", result.getTaskName(), result.getResult()); } else { System.out.printf("✗ %s: %s%n", result.getTaskName(), result.getError().getMessage()); } } } }

Resource Cleanup with Virtual Threads

import java.util.concurrent.*; import java.util.*; import java.util.concurrent.locks.*; public class ResourceManagementVirtualThreads { private final ExecutorService virtualThreadExecutor; private final Set<AutoCloseable> resources; private final ReentrantLock resourceLock; public ResourceManagementVirtualThreads() { this.virtualThreadExecutor = Executors.newVirtualThreadPerTaskExecutor(); this.resources = ConcurrentHashMap.newKeySet(); this.resourceLock = new ReentrantLock(); } public <T> CompletableFuture<T> executeWithResource( Callable<T> task, AutoCloseable resource) { // Register resource for cleanup resources.add(resource); return CompletableFuture.supplyAsync(() -> { try { T result = task.call(); return result; } catch (Exception e) { throw new CompletionException(e); } finally { // Always cleanup resource cleanupResource(resource); } }, virtualThreadExecutor); } private void cleanupResource(AutoCloseable resource) { resourceLock.lock(); try { if (resources.remove(resource)) { try { resource.close(); System.out.println("Resource cleaned up: " + resource); } catch (Exception e) { System.err.println("Error cleaning up resource: " + e.getMessage()); } } } finally { resourceLock.unlock(); } } public void shutdown() { // Cleanup any remaining resources resourceLock.lock(); try { for (AutoCloseable resource : resources) { try { resource.close(); } catch (Exception e) { System.err.println("Error during shutdown cleanup: " + e.getMessage()); } } resources.clear(); } finally { resourceLock.unlock(); } virtualThreadExecutor.shutdown(); } // Simulated resource private static class SimulatedResource implements AutoCloseable { private final String name; private volatile boolean closed = false; public SimulatedResource(String name) { this.name = name; } public String readData() throws Exception { if (closed) throw new IllegalStateException("Resource closed"); Thread.sleep(100); // Simulate I/O return "Data from " + name; } @Override public void close() throws Exception { if (!closed) { closed = true; Thread.sleep(50); // Simulate cleanup System.out.println("Closed resource: " + name); } } @Override public String toString() { return "SimulatedResource{name='" + name + "', closed=" + closed + "}"; } } public static void main(String[] args) throws Exception { ResourceManagementVirtualThreads manager = new ResourceManagementVirtualThreads(); List<CompletableFuture<String>> futures = new ArrayList<>(); for (int i = 0; i < 5; i++) { SimulatedResource resource = new SimulatedResource("Resource-" + i); CompletableFuture<String> future = manager.executeWithResource(() -> { String data = resource.readData(); System.out.println("Processed: " + data + " on " + Thread.currentThread().getName()); return data; }, resource); futures.add(future); } // Wait for all tasks CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join(); System.out.println("\nAll tasks completed. Resources should be cleaned up."); manager.shutdown(); } }

5. Performance Monitoring and Tuning

Virtual Threads Monitoring

import java.util.concurrent.*; import java.lang.management.*; import java.util.*; import java.util.concurrent.atomic.*; public class VirtualThreadsMonitoring { private final ExecutorService virtualThreadExecutor; private final ThreadMXBean threadMXBean; private final AtomicInteger tasksCompleted; private final AtomicInteger tasksFailed; public VirtualThreadsMonitoring() { this.virtualThreadExecutor = Executors.newVirtualThreadPerTaskExecutor(); this.threadMXBean = ManagementFactory.getThreadMXBean(); this.tasksCompleted = new AtomicInteger(); this.tasksFailed = new AtomicInteger(); } public void executeMonitoredTasks(int taskCount) throws Exception { List<CompletableFuture<Void>> futures = new ArrayList<>(); printThreadStats("Before task execution"); for (int i = 0; i < taskCount; i++) { final int taskId = i; CompletableFuture<Void> future = CompletableFuture.runAsync(() -> { try { executeMonitoredTask(taskId); tasksCompleted.incrementAndGet(); } catch (Exception e) { tasksFailed.incrementAndGet(); System.err.println("Task " + taskId + " failed: " + e.getMessage()); } }, virtualThreadExecutor); futures.add(future); } // Wait for all tasks CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join(); printThreadStats("After task execution"); printTaskStatistics(taskCount); } private void executeMonitoredTask(int taskId) throws InterruptedException { long startTime = System.currentTimeMillis(); // Simulate mixed I/O and computation if (taskId % 3 == 0) { // I/O intensive Thread.sleep(200); } else if (taskId % 3 == 1) { // Mixed Thread.sleep(100); doSomeComputation(); Thread.sleep(100); } else { // Computation with small I/O doSomeComputation(); Thread.sleep(50); } long duration = System.currentTimeMillis() - startTime; System.out.printf("Task %d completed in %d ms on %s%n", taskId, duration, Thread.currentThread().getName()); } private void doSomeComputation() { // Simulate CPU work long result = 0; for (int i = 0; i < 1000; i++) { result += i * i; } } private void printThreadStats(String phase) { System.out.println("\n=== " + phase + " ==="); System.out.println("Platform threads: " + threadMXBean.getThreadCount()); System.out.println("Peak threads: " + threadMXBean.getPeakThreadCount()); // Virtual thread stats (Java 21+) try { // This would require accessing internal APIs in real implementation System.out.println("Virtual threads: [monitoring not directly available]"); } catch (Exception e) { // Virtual thread monitoring might not be directly available } } private void printTaskStatistics(int totalTasks) { System.out.println("\n=== Task Statistics ==="); System.out.println("Total tasks: " + totalTasks); System.out.println("Completed: " + tasksCompleted.get()); System.out.println("Failed: " + tasksFailed.get()); System.out.println("Success rate: " + (tasksCompleted.get() * 100.0 / totalTasks) + "%"); } public void shutdown() { virtualThreadExecutor.shutdown(); } public static void main(String[] args) throws Exception { VirtualThreadsMonitoring monitor = new VirtualThreadsMonitoring(); try { monitor.executeMonitoredTasks(100); } finally { monitor.shutdown(); } } }

6. Best Practices and Patterns

Virtual Threads Best Practices

import java.util.concurrent.*; import java.util.*; public class VirtualThreadsBestPractices { // 1. Use for I/O-bound tasks, not CPU-bound tasks public void ioBoundWork() throws Exception { try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { List<Callable<String>> ioTasks = List.of( () -> { Thread.sleep(100); return "Database query result"; }, () -> { Thread.sleep(150); return "HTTP API response"; }, () -> { Thread.sleep(200); return "File read completed"; } ); List<Future<String>> results = executor.invokeAll(ioTasks); for (Future<String> result : results) { System.out.println(result.get()); } } } // 2. Avoid synchronized blocks with virtual threads public void useReentrantLockInsteadOfSynchronized() throws Exception { ReentrantLock lock = new ReentrantLock(); try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { List<Callable<String>> tasks = new ArrayList<>(); for (int i = 0; i < 10; i++) { final int taskId = i; tasks.add(() -> { lock.lock(); try { // Critical section Thread.sleep(50); return "Task " + taskId + " completed"; } finally { lock.unlock(); } }); } executor.invokeAll(tasks).forEach(future -> { try { System.out.println(future.get()); } catch (Exception e) { e.printStackTrace(); } }); } } // 3. Use CompletableFuture for complex async workflows public CompletableFuture<String> complexAsyncWorkflow() { try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { return CompletableFuture .supplyAsync(() -> fetchUserData(), executor) .thenApplyAsync(userData -> validateUserData(userData), executor) .thenComposeAsync(validData -> processUserData(validData), executor) .exceptionally(throwable -> { System.err.println("Workflow failed: " + throwable.getMessage()); return "Fallback result"; }); } } // 4. Proper resource cleanup with try-with-resources public void properResourceManagement() throws Exception { // ExecutorService implements AutoCloseable in virtual thread executors try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { executor.submit(() -> { // Simulate work with resources try (var connection = getDatabaseConnection(); var statement = connection.createStatement()) { Thread.sleep(100); System.out.println("Work completed with proper resource management"); } catch (Exception e) { throw new RuntimeException(e); } }); } // Executor automatically shutdown here } // 5. Batch operations for better throughput public void batchOperations(List<String> items) throws Exception { try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { int batchSize = 10; List<List<String>> batches = new ArrayList<>(); for (int i = 0; i < items.size(); i += batchSize) { batches.add(items.subList(i, Math.min(i + batchSize, items.size()))); } List<Callable<String>> batchTasks = batches.stream() .map(batch -> (Callable<String>) () -> processBatch(batch)) .toList(); List<Future<String>> results = executor.invokeAll(batchTasks); for (Future<String> result : results) { System.out.println("Batch result: " + result.get()); } } } // Helper methods private String fetchUserData() { try { Thread.sleep(100); } catch (InterruptedException e) { } return "User data"; } private String validateUserData(String data) { try { Thread.sleep(50); } catch (InterruptedException e) { } if (data == null) throw new IllegalArgumentException("Invalid data"); return data + " (validated)"; } private CompletableFuture<String> processUserData(String data) { return CompletableFuture.supplyAsync(() -> { try { Thread.sleep(100); } catch (InterruptedException e) { } return data + " (processed)"; }, Executors.newVirtualThreadPerTaskExecutor()); } private AutoCloseable getDatabaseConnection() { return new AutoCloseable() { @Override public void close() throws Exception { System.out.println("Connection closed"); } }; } private String processBatch(List<String> batch) { try { Thread.sleep(100); return "Processed batch of " + batch.size() + " items"; } catch (InterruptedException e) { throw new RuntimeException(e); } } public static void main(String[] args) throws Exception { VirtualThreadsBestPractices practices = new VirtualThreadsBestPractices(); System.out.println("=== I/O Bound Work ==="); practices.ioBoundWork(); System.out.println("\n=== Batch Operations ==="); List<String> items = new ArrayList<>(); for (int i = 0; i < 25; i++) { items.add("Item-" + i); } practices.batchOperations(items); System.out.println("\n=== Complex Async Workflow ==="); practices.complexAsyncWorkflow() .thenAccept(result -> System.out.println("Final result: " + result)) .join(); } }

Summary

Key Benefits of Virtual Threads:

Massive Concurrency: Create millions of virtual threads efficiently
Simplified Code: Write blocking code without thread pool management
Better Resource Utilization: Optimal for I/O-bound workloads
Platform Integration: Work with existing Java APIs seamlessly

Best Practices:

Use for I/O-bound tasks, not CPU-bound computation
Avoid synchronized blocks - use ReentrantLock instead
Use try-with-resources for ExecutorService cleanup
Leverage Structured Concurrency for task management
Monitor and tune based on application needs

Common Use Cases:

HTTP servers handling many concurrent requests
Database applications with many concurrent connections
Microservices with high concurrency requirements
Batch processing of I/O-intensive tasks
Async/await patterns with simplified code

Performance Characteristics:

Low memory footprint (~2KB per virtual thread vs ~1MB per platform thread)
Fast creation/destruction (microseconds vs milliseconds)
Efficient I/O operations with automatic yielding
Compatible with existing code and libraries

Virtual Threads represent a fundamental shift in Java concurrency, making highly concurrent applications much simpler to write and maintain while providing exceptional performance for I/O-bound workloads.