Java: What are Virtual Threads in Java?

Virtual threads — lightweight threads managed by JVM, not OS (Java 21+).

Key features:

• Lightweight — millions can run concurrently.
• Managed by JVM scheduler.
• Don't block OS threads.
• Same API as platform threads.
• Stack starts small (few KB) and grows as needed.
• Scheduled onto carrier threads (platform threads) for execution.

Creating virtual threads:

1// Factory method
2Thread vt = Thread.ofVirtual().start(() -> {
3    System.out.println("Hello from virtual thread");
4});
5
6// ExecutorService
7try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
8    IntStream.range(0, 100_000).forEach(i -> {
9        executor.submit(() -> {
10            Thread.sleep(Duration.ofSeconds(1));
11            return i;
12        });
13    });
14}

How it works:

1. Virtual threads are lightweight threads that run on carrier threads.
2. When a virtual thread blocks (e.g., I/O), it unmounts from the carrier thread.
3. The carrier thread becomes free to run other virtual threads.
4. When the I/O completes, the virtual thread resumes on any available carrier.
5. This allows millions of concurrent threads with minimal OS resource usage.

Performance considerations:

• Best for I/O-bound workloads (network, database, file I/O).
• Not beneficial for CPU-bound work (no parallelism gain).
• Monitor carrier thread pool size and virtual thread count.

Common pitfalls:

• Thread-local state: Virtual threads use carrier threads, so ThreadLocal values may leak.
• synchronized blocks: Can pin virtual threads to carrier threads, reducing scalability.
• Large stack sizes: Virtual threads start small but can grow, consuming memory.

When to use:

• I/O-bound workloads.
• Many concurrent connections.
• Blocking operations (DB, HTTP).
• Web servers handling many simultaneous requests.

When NOT to use:

• CPU-bound work.
• Thread-local state with large data.
• Legacy code using synchronized blocks extensively.