Thread by @bazlur_rahman

#Java 19 introduces virtual threads to the Java platform for the first time; this is the primary deliverable of OpenJDK's Project Loom.

This thread is all about it:
🧵

⬇️⬇️⬇️

Java is made of threads. When we run a Java program, its main method is invoked as the first call frame of the main thread created by the Java launcher. It gives us many things: sequential control flow, local variables, exception handling, single-step debugging, and profiling. ⬇️

It makes our lives easier by providing exception handling with informative stack traces and serviceability tools that let us observe what's happening in each thread, providing remote debugging, and creating an illusion of sequentiality that makes our code easier to reason.
⬇️

Most JVM implementations today implement Java threads as thin wrappers around operating system threads.
We call these heavyweight, OS-managed threads platform threads. 
⬇️

Operating systems typically allocate thread stacks as monolithic memory blocks at thread creation time that cannot be resized later—generally 2 MB (on Linux).
One million threads would require 2 terabytes of memory!
It essentially means that we can't have a lot of them.
⬇️

In a server application, a thread is assigned to each incoming request. This approach scales well for moderate-scale applications, e.g., 1000 concurrent requests, but cannot survive 1M concurrent requests, even though we have adequate CPU capacity and IO bandwidth.
⬇️

Virtual threads are an alternative implementation of Java threads that store their stack frames in Java's garbage-collected heap rather than in monolithic blocks of memory allocated by the OS. It starts out at only a few hundred bytes and expands and shrinks automatically.
⬇️

The operating system only knows about platform threads, which remain in the scheduling unit. To run code in a virtual thread, the Java runtime arranges for it to run by mounting it on some traditional thread called a "carrier thread."
⬇️

When code running in a virtual thread would otherwise block for IO, locking, or other resource availability, it can be unmounted from the carrier thread, and any modified stack frames copied back to the heap, which frees the carrier thread to run something else.
⬇️

With this virtual thread, we get all the benefits traditional threads have, plus it is cheap, lightweight, and virtually free. Moreover, we can create many of them.
The following example creates 100,000 virtual threads in under 2 seconds.  
⬇️

Since a large number of virtual threads are easy to create, the thread-per-request programming style alleviates this scalability bottleneck.
In other words, high throughput is very simple to achieve.
⬇️

Since this is a preview feature, a developer will need to provide the --enable-preview flag to compile this code, as shown in the following command:

javac --release 19 --enable-preview Main.java
⬇️

The same flag is also required to run the program:

java --enable-preview Main

However, one can directly run this using the source code launcher. In that case, the command line would be:

java --source 19 --enable-preview Main.java
⬇️

While Thread.startVirtualThread(Runnable) is the convenient way to create a virtual thread, new APIs like Thread.Builder, Thread.ofVirtual(), and Thread.ofPlatform() were added to create virtual and platform threads.
⬇️

Last but not least, if you liked this thread and want to read more like it in the future, follow me on Twitter (why wouldn't you?).