Представление Project Loom в Java Хабр

Over the years, before Virtual Threads were available, we have revised synchronized blocks which might potentially interact with third-party resources, removing lock contention in highly concurrent applications. So Spring is in pretty good shape already owing to its large community and extensive feedback from existing concurrent applications. Project Loom aims to bring “easy-to-use, high-throughput, lightweight concurrency” to the JRE. In this blog post, we’ll be exploring what virtual threads mean for web applications using some simple web applications deployed on Apache Tomcat.

I was able to run loom project by JosePaumard
There are multiple steps as of now to make it work. Scoped values feature was directly inspired by the Lisp dialects that provide support for dynamically scoped variables, hence its syntax might be a bit different than many will expect in “traditional” Java code. To solve all the mentioned pitfalls Oracle introduces a new -lightweight- data sharing system that makes the data immutable hence it can be shared by child threads efficiently. To understand why the scoped values feature was developed one needs to have a good understanding of the Thread Local variables, with all of its strong sides and downfalls. “Every six months, we’re getting new features out, and the fact that they’re able to preview them at an earlier stage [before incorporating them into the language] has helped Java start catching up to what other languages have been doing,” he said.

Java 20 Project Loom updates set stage for Java LTS

Common backend frameworks such as Spring and Quarkus can already handle virtual threads. Nevertheless, you should test applications intensively when you flip the switch to virtual threads. Make sure that you do not, for example, execute CPU-intensive computing tasks on them, that they are not pooled by the framework, and that no ThreadLocals are stored in them (see also Scoped Value). In these two cases, a blocked virtual thread will also block the carrier thread. To compensate for this, both operations temporarily increase the number of carrier threads – up to a maximum of 256 threads, which can be changed via the VM option jdk.virtualThreadScheduler.maxPoolSize. In the second variant, Thread.ofVirtual() returns a VirtualThreadBuilder whose start() method starts a virtual thread.

Overall, none of Java 20’s features were “earth-shattering,” according to Andrew Cornwall, an analyst at Forrester Research, but all stand to play an important role in updating Java for the 21st century. You can replace a synchronized block around blocking operation with a ReentrantLock. The reason for this is that in both cases, pointers to memory addresses on the stack can exist.

Configuring a Spring Boot project to use Java 21

At the beginning of the request handler you’ll call ScopedValue.where(…), presenting a scoped value and the object to which it is to be bound. The call to run(…) binds the scoped value, providing an incarnation that is specific to the current thread, and then executes the lambda expression passed as argument. During the lifetime of the run(…) call, the lambda expression, or any method called directly or indirectly from that expression, can read the scoped value via the value’s get() method. Conveniently you can store some data in the entry point of the request handler and use that data all across the workload of the request being executed without having to explicitly pass that data as a method argument across your codebase.

Loom and Java in general are prominently devoted to building web applications. Obviously, Java is used in many other areas, and the ideas introduced by Loom may be useful in a variety of applications. It’s easy to see how massively increasing thread efficiency and dramatically reducing the resource requirements for handling multiple competing needs will result in greater throughput for servers. Better handling of requests and responses is a bottom-line win for a whole universe of existing and future Java applications. 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 (at most). The implications of this for Java server scalability are breathtaking, as standard request processing is married to thread count.

Project Loom could help Java keep pace with web apps

Each platform thread had to process ten tasks sequentially, each lasting about one second. Project Loom has revisited all areas in the Java runtime libraries that can block and updated the code to yield if the code encounters blocking. Java’s concurrency utils (e.g. ReentrantLock, CountDownLatch, CompletableFuture) can be used on Virtual Threads without blocking underlying Platform Threads.

• The first command generates a thread dump similar to the traditional one, with thread names, IDs and stack traces.
• This uses the newThreadPerTaskExecutor with the default thread factory and thus uses a thread group.
• Another feature of Loom, structured concurrency, offers an alternative to thread semantics for concurrency.
• The implementation becomes even more fragile and puts a lot more responsibility on the developer to ensure there are no issues like thread leaks and cancellation delays.
• Web servers like Jetty have long been using NIO connectors, where you have just a few threads able to keep open hundreds of thousand or even a million connections.

Web servers like Jetty have long been using NIO connectors, where you have just a few threads able to keep open hundreds of thousand or even a million connections. To cut a long story short (and ignoring a whole lot of details), the real difference between our getURL calls inside good, old threads, and virtual threads is, that one call opens up a million blocking sockets, whereas the other call opens up a million non-blocking sockets. You can use this guide to understand what Java’s Project loom is all about and how its virtual threads (also called ‘fibers’) work under the hood. http://protyazhno.ru/anpagelin90-1.html Other than code simplicity, what’s really powerful here is a unified way of handing error scenarios of different executions running in the completely different (virtual or platform) threads. While this topic, like all else in the multithreaded realm is complex and requires quite some time to master, the code snippet down below should be a good example of the structured concurrency in action. Very simple benchmarking on a Intel CPU (i5–6200U) shows half a second (0.5s) for creating 9000 threads and only five seconds (5s) for launching and executing one million virtual threads.