Java’s Project Loom and virtual threads

Hence while Project Loom won’t replace the way we do concurrency in Java, it might provide yet another tool in our toolbox. And it will definitely be misused, as every other construct out there. But there will also be room for new libraries, which combine the managed environments in which IO computation descriptions are safely interpreted, with the “codes like sync, works like async” of Loom’s fibers.

In this scenario, cancellation is an out-of-band operation, independent of the exception mechanism. The operators that we might want to add can cover error handling, threadpool-pinning, repeated evaluation, caching, and most importantly, safe resource allocation. Fibers try to solve the above problems by making code synchronous again; or at least, by making code look as if it was doing synchronous calls. Numerous projects have shown that working directly with thread synchronization primitives usually leads to deadlocks, thread starvation or other bugs. If you’ve been coding in Java for a while, you’re probably well aware of the challenges and complexities that come with managing concurrency in Java applications. By clicking “Post Your Answer”, you agree to our terms of service and acknowledge that you have read and understand our privacy policy and code of conduct.

More from Adam Warski and SoftwareMill Tech Blog

Loom-driven simulations make much of this far simpler. Many races will only be exhibited in specific circumstances. For example, on a single core machine, in the absence of a sleep or control primitive like a CountDownLatch, it’s unlikely that the above bug could be found. By generating a lot of simulated context switching, a broader set of possible interleavings can be cheaply explored.

Whereas the OS can support up to a few thousand active threads, the Java runtime can support millions of virtual threads. Every unit of concurrency in the application domain can be represented by its own thread, making programming concurrent applications easier. Forget about thread-pools, just spawn a new thread, one per task. You’ve already spawned a new virtual thread to handle an incoming HTTP request, but now, in the course of handling the request, you want to simultaneously query a database and issue outgoing requests to three other services?

Project Loom: Understand the new Java concurrency model

With Project Loom, you no longer consume the so-called stack space. The virtual threads that are not running at the moment, which is technically called pinned, so they are not pinned to a carrier thread, but they are suspended. These virtual threads actually reside on heap, which means they are subject to garbage collection. In that case, it’s actually fairly easy to get into a situation where your garbage collector will have to do a lot of work, because you have a ton of virtual threads. You don’t pay the price of platform threads running and consuming memory, but you do get the extra price when it comes to garbage collection. The garbage collection may take significantly more time.

As one of the reasons for implementing continuations as an independent construct of fibers is a clear separation of concerns. Continuations, therefore, are not thread-safe and none of their operations creates cross-thread happens-before relations. Establishing the memory java project loom visibility guarantees necessary for migrating continuations from one kernel thread to another is the responsibility of the fiber implementation. A separate Fiber class might allow us more flexibility to deviate from Thread, but would also present some challenges.

More developer resources

When to use are obvious in textbook examples; a little less so in deeply nested logic. Lock avoidance makes that, for the most part, go away, and be limited to contended leaf components like malloc(). And debugging is indeed painful, and if one of the intermediary stages results with an exception, the control-flow goes hay-wire, resulting in further code to handle it.

As far as JVM is concerned, they do not exist, because they are suspended. With Project Loom, we simply start 10,000 threads, each thread per each image. Using the structured concurrency, it’s actually fairly simple.

Virtual Threads

There is one-to-one mapping, which means effectively, if you create 100 threads, in the JVM you create 100 kernel resources, 100 kernel threads that are managed by the kernel itself. For example, thread priorities in the JVM are effectively ignored, because the priorities are actually handled by the operating system, and you cannot do much about them. When a particular implementation is referred, the terms heavyweight thread, kernel threads and OS thread can be used interchangeable to mean the implementation of thread provided by the operating system kernel.

• We could call the previously defined process function directly, but for the sake of clarity, and reduce the number of instanciations gap between the different scenario, we will create the Runnable version of the origami task.
• When building a database, a challenging component is building a benchmarking harness.
• All the benefits threads give us — control flow, exception context, debugging flow, profiling organization — are preserved by virtual threads; only the runtime cost in footprint and performance is gone.
• With Project Loom, we will have at least one more such option to choose from.
• Few new methods are introduced in the Java Thread class.

This has been facilitated by changes to support virtual threads at the JVM TI level. We’ve also engaged the IntelliJ IDEA and NetBeans debugger teams to test debugging virtual threads in those IDEs. You might think that it’s actually fantastic because you’re handling more load.

Project Loom: Revolution in Java Concurrency or Obscure Implementation Detail?

We’ve adapted those, so that java.util.concurrent is virtual-thread friendly. We say that a virtual thread is pinned to its carrier if it is mounted but is in a state in which it cannot be unmounted. If a virtual thread blocks while pinned, it blocks its carrier. This behavior is still correct, but it holds on to a worker thread for the duration that the virtual thread is blocked, making it unavailable for other virtual threads. Discussions over the runtime characteristics of virtual threads should be brought to the loom-dev mailing list. The java.lang.Thread class dates back to Java 1.0, and over the years accumulated both methods and internal fields.

It works as long as these threads are not doing too much work. If you have a ton of threads that are not doing much, they’re just waiting for data to arrive, or they are just locked on a synchronization mechanism waiting for a semaphore or CountDownLatch, whatever, then Project Loom https://www.globalcloudteam.com/ works really well. We no longer have to think about this low level abstraction of a thread, we can now simply create a thread every time for every time we have a business use case for that. There is no leaky abstraction of expensive threads because they are no longer expensive.

When to choose or avoid virtual threads

Code running inside a continuation is not expected to have a reference to the continuation, and the scopes normally have some fixed names . However, the yield point provides a mechanism to pass information from the code to the continuation instance and back. When a continuation suspends, no try/finally blocks enclosing the yield point are triggered (i.e., code running in a continuation cannot detect that it is in the process of suspending). In the literature, nested continuations that allow such behavior are sometimes call “delimited continuations with multiple named prompts”, but we’ll call them scoped continuations.