Java Concurrency: An Introduction to Project Loom

Both are part of the Loom project and are previewed/incubated in Java 19. First of all, each Saft Node is run on a dedicated thread. This is especially important when running an in-memory Saft simulation https://globalcloudteam.com/ with multiple nodes running on a single JVM. But for that, we could have easily used a dedicated OS thread. The heart of Saft, that is the Node class, follows the same pattern as before.

To give you a sense of how ambitious the changes in Loom are, current Java threading, even with hefty servers, is counted in the thousands of threads . Loom proposes to move this limit towards million of threads. The implications of this for Java server scalability are breathtaking, as standard request processing is married to thread count.

The try-with-resources construct allows to introduce “structure into your concurrency”. If you want to get more exotic, then Loom provides possibilities to restrict virtual threads to a pool of carrier threads. project loom java However, this feature can lead to unexpected consequences, as outlined in Going inside Java’s Project Loom and virtual threads. This is far more performant than using platform threads with thread pools.

Learn more about Java, multi-threading, and Project Loom

Then we move on, and in line five, we run the continuation once again. Not really, it will jump straight to line 17, which essentially means we are continuing from the place we left off. Continuations are actually useful, even without multi-threading. This makes lightweight Virtual Threads an exciting approach for application developers and the Spring Framework. Past years indicated a trend towards applications that communicate over the network with each other.

The Loom team has stated that they aim to fix this limitation, so the problem may no longer exist by the time virtual threads become GA. However, if it doesn’t get solved before then, and this is a significant enough performance issue for you, then you may want to do something about it. For example, if you wanted to cap concurrent accesses to a shared resource to 100, then you could use the method Executors.newFixedThreadPool.

Java Developer Productivity Report

The core idea is that the system will be able to avoid allocating new stacks for continuations wherever possible. This approach gives developers plenty of room to make mistakes or confuse existing and unrelated concurrency abstractions with the new constructs. In addition, business intent is blurred by the extra verbosity of Java. We want updateInventory() and updateOrder() subtasks to be executed concurrently.

And the implementations provided by the core Java library provide the necessary code for you. This is why in the first preview of virtual threads in Java 19 includes a new class of ExecutorService that creates a new virtual Thread to run each submitted task, on-demand. See the Javadocs for factory method Executors.newVirtualThreadPerTaskExecutor() which also notes that the number of threads created by the Executor is unbounded. Loom introduces coroutines, termed virtual threads, as native element into the JVM.

Loom and the future of Java

Therefore you no longer need to write code that avoids blocking a thread (e.g. by using reactive, async APIs) – it’s a waste of time. Now we have virtual threads, writing imperative code that blocks on I/O is ok. This is a benefit because imperative, blocking code is a lot easier to maintain than async code. I will be talking about Project Loom, which is not yet available.

• Technically, you can have millions of virtual threads that are sleeping without really paying that much in terms of the memory consumption.
• Structured concurrency aims to simplify multi-threaded and parallel programming.
• Project Loom allows us to write highly scalable code with the one lightweight thread per task.
• Jeroen is often engaged in knowledge sharing through talks, blogs, projects at github, and trainings.
• This doesn’t mean that virtual threads will be the one solution for all; there will still be use cases and benefits for asynchronous and reactive programming.

Since it runs on its own thread, it can complete successfully. But now we have an issue with a mismatch in inventory and order. Suppose the updateOrder() is an expensive operation. In that case, we are just wasting the resources for nothing, and we will have to write some sort of guard logic to revert the updates done to order as our overall operation has failed.

Virtual threads are multiplexed onto a much smaller pool of system threads with efficient context switches. Adding Loom to Java will definitively open up a new domain of problems, bugs and best practices. Which means that in the short term, probably nothing will change for Java or Kotlin development. Once Loom is established and if companies and development teams decide to rewrite their existing code-base to use Loom as concurrency approach, they might instead decide to switch to Kotlin altogether. In particular in so called “business domains”, such as e-commerce, insurances and banks, Kotlin provides additional safety, whereas Java does not. Blocking operations thus no longer block the executing thread.

As the executed code doesn’t hit any of the JDK’s blocking methods, the threads never yield and thus ursurpate their carrier threads until they have run to completion. This represents an unfair scheduling scheme of the threads. While they were all started at the same time, for the first two seconds only eight of them were actually executed, followed by the next eight, and so on. Structured concurrency aims to simplify multi-threaded and parallel programming.

You can visit Execution model, blocking, non-blockingfor more information. Their argument for this change is that in this case the use of a Semaphore more clearly shows the intent than using an ExecutorService. Whilst that’s true, the counter argument is that it requires you to write and test extra code which isn’t needed when using an ExecutorService. Although as shown above the amount of extra code is small. Loom has the upper hand when it comes to syntax familiarity and simpler types (no viral Future / IO wrappers).

Adopting Virtual Threads (in the Future)

Use of ExecutorService still has its place though, as an out of the box implementation of an abstraction for creating threads used to run tasks. For production apps, adoption of virtual threads is best deferred until after they have been finalised and become GA in a future version of Java. In the meantime, if you want to experiment with virtual threads you’ll need to install JDK 19 and enable preview features when compiling and running your app. For more details see the Further Reading section below.

If instead you create 4 virtual threads, you will basically do the same amount of work. It doesn’t mean that if you replace 4 virtual threads with 400 virtual threads, you will actually make your application faster, because after all, you do use the CPU. There’s not much hardware to do the actual work, but it gets worse. Because if you have a virtual thread that just keeps using the CPU, it will never voluntarily suspend itself, because it never reaches a blocking operation like sleeping, locking, waiting for I/O, and so on. In that case, it’s actually possible that you will only have a handful of virtual threads that never allow any other virtual threads to run, because they just keep using the CPU. That’s the problem that’s already handled by platform threads or kernel threads because they do support preemption, so stopping a thread in some arbitrary moment in time.

What is the Java concurrency problem?

To utilize the CPU effectively, the number of context switches should be minimized. From the CPU’s point of view, it would be perfect if exactly one thread ran permanently on each core and was never replaced. We won’t usually be able to achieve this state, since there are other processes running on the server besides the JVM. But “the more, the merrier” doesn’t apply for native threads – you can definitely overdo it.

There’s also a different algorithm or a different initiative coming as part of Project Loom called structured concurrency. Essentially, it allows us to create an ExecutorService that waits for all tasks that were submitted to it in a try with resources block. This is just a minor addition to the API, and it may change. This is a main function that calls foo, then foo calls bar. There’s nothing really exciting here, except from the fact that the foo function is wrapped in a continuation.

It’s just a different way of performing or developing software. I will not go into the API too much because it’s subject to change. You essentially say Thread.startVirtualThread, as opposed to new thread or starting a platform thread.

Problems and Limitations – Stack vs. Heap Memory

Microsoft Azure supports your workload with abundant choices, whether you’re working on a Java app, app server, or framework. One of the main goals of Project Loom is to actually rewrite all the standard APIs. For example, socket API, or file API, or lock APIs, so lock support, semaphores, CountDownLatches. All of these APIs need to be rewritten so that they play well with Project Loom. However, there’s a whole bunch of APIs, most importantly, the file API.

In the very prehistoric days, in the very beginning of the Java platform, there used to be this mechanism called the many-to-one model. The JVM was actually creating user threads, so every time you set newthread.start, a JVM was creating a new user thread. However, these threads, all of them were actually mapped to a single kernel thread, meaning that the JVM was only utilizing a single thread in your operating system. It was doing all the scheduling, so making sure your user threads are effectively using the CPU.

Kotlin and Java Loom: structured concurrency for the masses

However, instead of representing side effects as immutable, lazily-evaluated descriptions, we’ll use direct, virtual-thread-blocking calls. But let’s not get ahead of ourselves, and introduce the main actors. That’s right; you may no longer need any ExecutorServices. To be honest, it’s a leaky abstraction anyway that needs to be fine-tuned and monitored. What if you could simply spawn a new thread whenever it makes sense? Start thinking about tasks to perform, not physical threads that you must manage.

Should you just blindly install the new version of Java whenever it comes out and just switch to virtual threads? First of all, the semantics of your application change. You no longer have this natural way of throttling because you have a limited number of threads. Also, the profile of your garbage collection will be much different. In the thread-per-request model with synchronous I/O, this results in the thread being “blocked” for the duration of the I/O operation.