Virtual Threads: A Game-Changer for Concurrency

public class PlatformThreadMemoryAnalyzer {

    private static class MyTask implements Runnable {

        @Override
        public void run() {
            try {
                // Sleep for 10 minutes
                Thread.sleep(600000);
            } catch (InterruptedException e) {
                System.err.println("Interrupted Exception!!");
            }
        }
    }

    public static void main(String args[]) throws Exception {
        // Create 10000 platform threads
        int i = 0;
        while (i < 10000) {
            Thread myThread = new Thread(new MyTask());
            myThread.start();
            i++;
        }
        Thread.sleep(600000);
    }
}

Program 2: Create 10,000 Virtual Threads

public class VirtualThreadMemoryAnalyzer {

    private static class MyTask implements Runnable {

        @Override
        public void run() {
            try {
                // Sleep for 10 minutes
                Thread.sleep(600000);
            } catch (InterruptedException e) {
                System.err.println("Interrupted Exception!!");
            }
        }
    }

    public static void main(String args[]) throws Exception {
        // Create 10000 virtual threads
        int i = 0;
        while (i < 10000) {
            Thread.ofVirtual().start(new Task());
            i++;
        }
        Thread.sleep(600000);
    }
}

Executed both programs simultaneously in a RedHat VM. Configured the thread stack size to be 1mb (by passing JVM argument -Xss1m). This argument indicates that every thread in this application should be allocated 1mb of stack size. Below is the top command output of the threads running.

You can notice that the virtual threads only occupies 7.8mb (i.e., 7842364 bytes), whereas the platform threads program occupies 19.2gb. This clearly indicates that virtual threads consume comparatively much less memory.

Thread Creation Time

Program 1: Launches 10,000 platform threads

public class PlatformThreadCreationTimeAnalyzer {

    private static class Task implements Runnable {

        @Override
        public void run() {
            System.out.println("Hello! I am a Platform Thread");
        }
    }

    public static void main(String[] args) throws Exception {
        long startTime = System.currentTimeMillis();
        for (int counter = 0; counter < 10_000; ++counter) {
            new Thread(new Task()).start();
        }
        System.out.print("Platform Thread Creation Time: " + (System.currentTimeMillis() - startTime));
    }
}

Program 2: Launches 10,000 virtual threads

public class VirtualThreadCreationTimeAnalyzer {

    private static class Task implements Runnable {

        @Override
        public void run() {
            System.out.println("Hello! I am a Virtual Thread");
        }
    }

    public static void main(String[] args) throws Exception {
        long startTime = System.currentTimeMillis();
        for (int counter = 0; counter < 10_000; ++counter) {
            Thread.startVirtualThread(new Task());
        }
        System.out.print("Virtual Thread Creation Time: " + (System.currentTimeMillis() - startTime));
    }

}

Below is the table that summarizes the execution time of these two programs:

You can see that the virtual Thread took only 84 ms to complete, whereas the Platform Thread took almost 346 ms. It’s because platform threads are more expensive to create. Because whenever a platform needs to be created an operating system thread needs to be allocated to it. Creating and allocating an operating system thread is not a cheap operation.

Reweaving the Fabric: Applications of Virtual Threads

Virtual threads can significantly benefit various types of applications, especially those requiring high concurrency and efficient resource management. Here are a few examples:

1. Web servers: Handling a large number of simultaneous HTTP requests can be efficiently managed with virtual threads, reducing the overhead and complexity of traditional thread pools.
2. Microservices: Microservices often involve a lot of I/O operations, such as database queries and network calls. Virtual threads can handle these operations more efficiently.
3. Data processing: Applications that process large amounts of data concurrently can benefit from the scalability of virtual threads, improving throughput and performance.

Weaving Success: Avoiding Pitfalls

To make the most out of virtual threads, consider the following best practices:

1. Avoid synchronized blocks/methods: When using virtual threads with synchronized blocks, they may not relinquish control of the underlying OS thread when blocked, limiting their benefits.
   
2. Avoid thread pools for virtual threads: Virtual threads are meant to be used without traditional thread pools. The JVM manages them efficiently, and thread pools can introduce unnecessary complexity.
3. Reduce ThreadLocal usage: Millions of virtual threads with individual ThreadLocal variables can rapidly consume Java heap memory.

Wrapping It Up