Virtual Threads in Java 21

Virtual Threads in Java 21 (Project Loom)

Java 21 introduces Virtual Threads as a standard feature, marking one of the most significant changes to Java’s concurrency model since the introduction of threads. Virtual Threads are part of Project Loom, an initiative aimed at improving Java’s concurrency handling, making it more lightweight, scalable, and developer-friendly.

What are Virtual Threads?

Virtual Threads are lightweight threads that are managed by the JVM (Java Virtual Machine), rather than the operating system (OS). They allow developers to create and manage millions of threads efficiently, without the performance and memory overhead associated with traditional platform threads (also known as OS threads).
Unlike traditional threads, virtual threads are scheduled by the JVM itself, rather than relying on the operating system to handle them. This allows for much better scaling, as virtual threads do not consume as many resources (especially memory) as platform threads.

Key Characteristics of Virtual Threads:

Lightweight:
- Virtual threads are extremely lightweight and are designed to handle millions of threads in the same JVM process. They use far less memory than traditional OS threads.
Efficient Context Switching:
- Because virtual threads are managed by the JVM, context switching between virtual threads is more efficient compared to OS-level threads. This results in better CPU utilization.
Simplified Concurrency:
- Traditional thread pools and complex concurrency patterns can be avoided. With virtual threads, developers can write simple, blocking code while benefiting from high concurrency.
Non-blocking at Scale:
- Blocking operations (such as I/O, database calls, and network requests) do not hold up platform threads, allowing for higher throughput. The JVM manages blocking of virtual threads by yielding the underlying platform thread and rescheduling it when the operation completes.
No Need for Thread Pools:
- Since virtual threads are cheap to create and destroy, the need for thread pools is significantly reduced. Developers can create as many threads as they need without worrying about resource exhaustion.

Difference Between Virtual Threads and Platform Threads (OS Threads)

Aspect	Platform Threads (OS Threads)	Virtual Threads (Java 21)
Managed By	Operating System	JVM
Thread Creation	Heavyweight, limited by OS resources	Lightweight, virtually unlimited
Memory Consumption	High (2MB or more per thread stack)	Low (less than 1KB per thread)
Context Switching	Managed by the OS (can be slow)	Managed by JVM (more efficient)
Concurrency Handling	Uses thread pools for large-scale concurrency	No need for thread pools; direct threading
Blocking Behavior	OS threads block when performing I/O	JVM handles blocking more efficiently
Ideal Use Case	Limited concurrency, computationally intensive tasks	Highly concurrent I/O-bound or mixed workloads

How Virtual Threads Work:

When a virtual thread performs a blocking operation (such as I/O or sleeping), the JVM "parks" the virtual thread and reuses the underlying OS thread to do other work. Once the blocking operation completes, the virtual thread resumes its execution.
Virtual threads decouple the number of threads from the number of CPUs or OS threads, meaning that your Java applications can handle many more concurrent tasks than would be possible with traditional OS threads.

Code Example Using Virtual Threads (Java 21)

Here’s an example to demonstrate how virtual threads can be used:

public class VirtualThreadExample {
    public static void main(String[] args) throws InterruptedException {
        // Creating a virtual thread
        Thread virtualThread = Thread.ofVirtual().start(() -&gt; {
            System.out.println("Virtual Thread: " + Thread.currentThread());
            try {
                Thread.sleep(1000); // Simulate blocking operation
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // Joining the virtual thread to ensure it completes before the main thread exits
        virtualThread.join();

        // Creating and running multiple virtual threads
        for (int i = 0; i &lt; 1000; i++) {
            Thread.ofVirtual().start(() -&gt; {
                System.out.println("Thread: " + Thread.currentThread().getName());
            });
        }

        System.out.println("Main thread finished.");
    }
}

public class VirtualThreadExample {

public static void main(String[] args) throws InterruptedException {

// Creating a virtual thread

Thread virtualThread = Thread.ofVirtual().start(() -> {

System.out.println("Virtual Thread: " + Thread.currentThread());

try {

Thread.sleep(1000); // Simulate blocking operation

} catch (InterruptedException e) {

Thread.currentThread().interrupt();

}

});

// Joining the virtual thread to ensure it completes before the main thread exits

virtualThread.join();

// Creating and running multiple virtual threads

for (int i = 0; i < 1000; i++) {

Thread.ofVirtual().start(() -> {

System.out.println("Thread: " + Thread.currentThread().getName());

});

}

System.out.println("Main thread finished.");

}

Explanation of Code:

We use Thread.ofVirtual() to create a virtual thread.
The start() method starts the virtual thread, and we can perform blocking operations such as Thread.sleep() without consuming OS resources.
In this example, we also create 1000 virtual threads in a loop, which would be expensive with platform threads but is easily handled by virtual threads.

Benefits of Virtual Threads:

Simplified Concurrency Model:
- Developers can write blocking code (simpler to understand and debug) without worrying about the performance penalties of blocking threads.
Efficient Resource Utilization:
- Virtual threads allow applications to handle more concurrent tasks without running into resource bottlenecks (like thread pool exhaustion or high memory usage).
Improved Throughput:
- Applications that perform I/O-bound tasks, such as web servers, database clients, and network applications, can achieve higher throughput since virtual threads efficiently manage blocking and concurrency.
No Need for Thread Pooling:
- Thread pooling was necessary for platform threads to optimize resource usage, but virtual threads are so lightweight that creating a thread per task is feasible.

Use Cases for Virtual Threads:

Highly Concurrent Applications:
- Applications with high concurrency requirements, such as web servers, REST APIs, or microservices, can greatly benefit from virtual threads since these applications often have to handle hundreds or thousands of concurrent requests.
I/O-Bound Workloads:
- Virtual threads shine in scenarios where threads spend a lot of time waiting on external resources, such as reading/writing files, network communication, or database access.
Simplified Task Handling in Task Executors:
- With virtual threads, the need for complex thread-pooling mechanisms is significantly reduced, making task management simpler and more efficient in task executors.
Server-Side Applications:
- Server applications, such as web servers and databases, often handle numerous concurrent clients. Virtual threads allow for scalability in such systems, improving the server’s capacity to handle large numbers of concurrent connections.

Comparison with Reactive Programming

Virtual threads provide an alternative to reactive programming (like RxJava or Project Reactor). Reactive frameworks deal with concurrency using asynchronous, non-blocking code, which can be complex to write and debug.

Virtual Threads simplify the concurrency model because you can write imperative blocking code that behaves in a non-blocking manner under the hood.
Reactive programming still has advantages for low-latency systems or systems with very tight resource requirements, but virtual threads reduce the need for reactive approaches in many cases.

When to Use Virtual Threads:

Highly concurrent but blocking tasks: If your application spends most of its time waiting on I/O or other blocking operations, virtual threads are ideal.
Simpler code: Virtual threads allow you to write code in a blocking, imperative style while still benefiting from high concurrency, without needing complex frameworks or thread pools.
Avoiding complexity: If managing thread pools or adopting reactive programming seems overly complex for your use case, virtual threads provide a simpler alternative.

Limitations of Virtual Threads

Not for CPU-bound tasks:
- Virtual threads are best suited for tasks that involve blocking operations (I/O-bound). For CPU-bound tasks, traditional platform threads or thread pools might still be more efficient, especially for multi-threaded processing where the tasks need to utilize multiple CPU cores.
Integration with existing libraries:
- Some libraries that rely on OS-level thread mechanisms or synchronization constructs may not yet be optimized for virtual threads. Over time, the ecosystem will likely catch up, but it’s something to consider when adopting virtual threads.
Limited support for certain low-level operations:
- Since virtual threads are managed by the JVM, certain low-level operations that directly interact with OS threads (like native code or custom synchronization primitives) may not fully benefit from virtual threads.

Conclusion:

Virtual Threads in Java 21 represent a major advancement in Java’s concurrency model. They provide a simpler, more efficient way to handle high concurrency without the complexities and resource overhead of traditional OS-level threads. By making it easier to write scalable, concurrent applications with simpler, blocking code, virtual threads are set to revolutionize how Java developers approach multithreaded programming, particularly in server-side and I/O-heavy applications.

New Dev Point

Some problems explained