Virtual Threads in JDK 21: Revolutionizing Java Multithreading

What is Virtual Thread

Multi-threading is a widely used feature across the industry for developing Java-based applications. It allows us to run operations in parallel, enabling faster task execution. The number of threads created by any Java application is limited by the number of parallel operations the OS can handle; in other words, the number of threads in a Java application is equal to the number of OS threads. Until now, this limitation has created a bottleneck on further scaling any application, considering the current fast-paced ecosystem. 

To overcome this limitation, Java has introduced the concept of Virtual Thread in JDK21. A Java application creates a Virtual Thread and is not associated with any OS thread. It means every Virtual Thread does not need to be dependent on a Platform Thread (aka OS thread). Virtual Thread will work on any task independently and will acquire a Platform Thread only when it needs to perform any I/O operation. 

This mechanism for acquiring and releasing Platform Threads gives an application the flexibility to create as many Virtual Threads as possible and achieve high concurrency.

Threads Before JDK 21

All the threads that were instances of java.lang.Thread class before JDK 21 were OS threads, aka Platform Threads. 

That meant every time a thread was created in the JDK environment, it was supposed to be mapped with a platform thread. This mechanism has added a limitation on the number of threads that can be created in a JVM environment. Due to the high cost of creating a Platform Thread, threads used to get pooled to avoid creating them again and again, a process that added extra cost to the application performance.

Threads After JDK 21

With JDK 21, the application developer can choose to create a virtual threa instead of Platform Thread using the Thread.ofVirtual() API or Executors.newVirtualThreadPerTaskExecutor(). 

The thread created this way is internal to the JVM, and no OS thread is occupied. All concurrent tasks can be done by a Virtual Thread in the same way as a Platform Thread does. A Virtual thread requires a Platform thread to perform an I/O operation, and once I/O is complete, the Virtual thread will release the Platform thread. Virtual Threads do not require management in a pool. Instead we can have an unlimited number of Virtual Threads in the System since they are internal to the JVM.

Why Virtual Thread?

• High Throughput: Tasks that consist of a large number of concurrent operations spend much of their time in waiting ex.Server Applications. Web Servers typically handle many client requests. In the absence of Virtual Threads, their capacity to handle parallel requests is limited. Using Virtual Threads can serve a large number of concurrent requests and add to their capacity.
• No Thread Pooling: - Virtual threads are inexpensive with enough availability, hence need never be pooled. For each concurrent task, we can create a Virtual Thread, and it is as easy as creating an Object in JVM memory. 
• High Performance: – Creating a virtual thread is less time-consuming (because no OS-level activity occurs), hence overall application performance will improve.
• Less Memory Consumption: –   Each Virtual Thread maintains a stack in heap to store local variables and method calls. Each Virtual Thread can spawn multiple Virtual Threads, and they are considered short-lived, we expect a shallow call stacks for each Thread, consuming little memory.
• Scalable Solution: APITheavy applications are generally designed in a thread-per-request style. Since virtual threads allow the JVM to create a greater number of threads compared to platform thread, applications can scale to serve many client requests.

How to Create Virtual Thread

The current JDK framework supports two ways to create virtual thread. Below is the sample code to create virtual threads.

Approach 1 – Using Thread.Builder Interface

Approach 2 – ExecuterService framework

Performance Comparison: Virtual Thread vs Platform Thread)

I have created a basic program to showcase the performance difference between virtual threads and platform threads. 

Code Snippets

Execution

Execute the program with virtual thread on:

Execute the program with platform thread on 

Comment the virtual thread, create code in Main.java, and uncomment the platform thread creation code.

Based on the above result, it is evident that when the program is creating 1000 virtual threads and performing a certain operation, it takes 147 ms, whereas the same code, if run using platform threads, takes around 551 ms to complete. Hence, virtual threads deliver better performance than platform threads.

Best Practices When Using Virtual Threads

• Virtual thread will be pinned to any platform thread only when there is a synchronized block execution. Hence, avoid frequent, long-duration synchronized blocks so that platform threads are short-lived, and we can take full advantage of the virtual thread model.
• Neve create a pool of virtual threads because virtual threads are available in large volumes; there is little overhead in creating a new virtual thread. If there is no thread pooling, then JVM does not need to work on complex logic to maintain a thread pool and scheduling.
• Avoid asynchronous code-writing techniques, because in synchronous code, the server dedicates a thread to processing each incoming request for its entire duration. Since virtual threads can be plentiful, blocking them is cheap and encouraged.
• Virtual thread supports thread-local variables. However, because virtual threads can be numerous, use thread locals only after careful consideration. Do not use thread locals to pool costly resources among multiple tasks sharing the same thread in a thread pool.