Do virtual threads replace CompletableFuture?

• Virtual threads – lightweight threads managed by the JVM, not the OS; each uses ~1KB stack instead of ~1MB for platform threads.
• Carrier threads – a small pool of platform threads that virtual threads are mounted on; when a virtual thread blocks on IO, the JVM unmounts it and the carrier serves another virtual thread.
• Replaces – custom thread pool sizing for IO, @Async annotations, simple supplyAsync() wrapping of blocking calls.
• Does not replace CF – thenCombine, allOf, anyOf, orTimeout, exceptionally for composing parallel calls with timeouts and fallbacks.
• Does not replace platform pools – CPU-bound parallelism needs all cores busy; virtual threads do not speed up computation.
• Coexistence – virtual threads for IO fan-out, CF for composition, platform pools for CPU-bound work.

What are virtual threads?

Virtual threads (Java 21, Project Loom) are lightweight threads managed by the JVM. Unlike platform threads (one-to-one with OS threads), virtual threads are multiplexed onto a small pool of carrier platform threads.

// Creating virtual threads (Java 21)
Thread vt = Thread.ofVirtual().start(() -> {
    String result = httpGet("https://api.bank.com/balance");
    // Blocks, but JVM unmounts this virtual thread
    // Carrier thread freed for another virtual thread
});

// Executor with virtual threads
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 100_000; i++) {
        executor.submit(() -> {
            jdbcQuery("SELECT balance FROM accounts");
            // 100K virtual threads, each blocking on JDBC
            // All on ~4 carrier threads!
        });
    }
}

What do virtual threads replace?

Before virtual threads, IO-bound concurrency required async code or thread pool tuning.

// BEFORE: @Async + custom pool + CF wrapping
// @Async("asyncPool")
// public CompletableFuture<Balance> getBalance(String id) {
//     return CompletableFuture.supplyAsync(() -> repo.findById(id), asyncPool);
// }

// AFTER: simple blocking code on virtual thread
public Balance getBalance(String id) {
    return repo.findById(id); // simple blocking call!
}
// Called from a virtual thread: blocking is free!

What does CompletableFuture still do better?

1. Composing independent parallel calls

CompletableFuture<Void> all = CompletableFuture.allOf(
    supplyAsync(() -> getBalance()),
    supplyAsync(() -> getCreditScore()),
    supplyAsync(() -> getPropertyValue())
);
all.join();
// Virtual threads: manually start 3 threads + join them
// CF: cleaner composition with allOf/anyOf/thenCombine

2. Timeouts and fallbacks

cf.orTimeout(5, TimeUnit.SECONDS)
  .exceptionally(ex -> fallbackValue);
// Virtual threads: no built-in timeout/fallback pipeline

What do platform pools still do better?

CPU-bound work needs all cores busy. Virtual threads do not speed up compute: they share the same carrier pool (cores threads).

// CPU-bound: platform pool still best
data.parallelStream().map(this::encrypt).sum(); // ForkJoinPool
// Virtual threads: no advantage for CPU-bound work

What is the summary?

| Workload | Best tool |
|---|---|
| IO-bound fan-out (10K requests) | Virtual threads |
| Compose/combine/timeout | CompletableFuture |
| CPU-bound parallelism | Platform thread pool / ForkJoinPool |
| Simple blocking call at scale | Virtual threads |
| Pipeline with fallbacks | CompletableFuture |

What are common mistakes with virtual threads?

// WRONG: pinning virtual thread with synchronized
synchronized (lock) {
    blockingIO(); // virtual thread PINNED to carrier, cannot unmount!
}
// Use ReentrantLock instead:
lock.lock();
try { blockingIO(); } finally { lock.unlock(); }

// WRONG: thread-local caching in virtual threads
ThreadLocal<Connection> connCache = new ThreadLocal<>();
// Millions of virtual threads x 1 connection each = OOM!
// Use connection pooling (HikariCP) instead.

What are common interview follow-up questions?

• Do virtual threads replace thread pools? For IO-bound work, yes. For CPU-bound, no.
• Can you use CompletableFuture with virtual threads? Yes, pass a virtual thread executor: supplyAsync(task, virtualExecutor).
• What is thread pinning? When a virtual thread holds a monitor (synchronized), the JVM cannot unmount it from the carrier, blocking the carrier.