Structured Concurrency on JAVAPRO International

Java 25 and the New Age of Performance: Virtual Threads and Beyond

Thu, 05 Mar 2026 07:00:01 +0000

Summary

Project Loom continues to reshape how we handle concurrency in the JVM, and Java 25 makes virtual threads more accessible to developers than ever. In this article, we’ll take a closer look at how virtual threads work, how they differ from platform threads, and where they provide the most benefit in real-world applications. We’ll also include performance benchmarks and a step-by-step guide for refactoring blocking I/O services to use virtual threads.

Virtual Threads, Structured Concurrency and Scoped Values: Putting it all together

Thu, 19 Feb 2026 07:00:01 +0000

In this article we are going to discuss Virtual Threads, Structured Concurrency and Scoped Values, the three main features of Project Loom and see how we can put them all together, in a web application. We will create a Spring Boot application and then add these features one by one to see how these features fit together nicely enabling us to write readable concurrent programs.

What is Project Loom?

Project Loom is one of the most important projects at Open JDK. The purpose of Project Loom is to provide high throughput, lightweight concurrency, which is also easy to use. It does so by providing three features: virtual threads, structured concurrency and scoped values. Virtual threads are lightweight, high-throughput threads that scale effortlessly. Structured concurrency is a streamlined approach to managing concurrent tasks as a single unit of work and scoped values are a modern alternative to ThreadLocal, designed for virtual threads.

How To Do Structured Concurrency in Java 25

Wed, 28 Jan 2026 07:00:02 +0000

It was a Friday night and we’d gone out for some drinks with a few colleagues. We ended up at one of those places where the drinks aren’t listed on the menu, so when the waiter asked us what drink we wanted we just asked if he could list a few. He was being very thorough, because he started listing all the options, and by the time he got to the 25th item some of us were like: “What was the first option again?” 🙈 We could tell he was trying to be patient, but his list recital had been for nothing and he couldn’t completely hide his disappointment. Concurrent programming with Java can sometimes be exactly like that. When you configure a few threads to do work in parallel, some of the work you let them do could potentially be for nothing. Java 25 previews a feature called ‘structured concurrency’, allowing you to prevent unnecessary work like this.

Java 25: Getting the Most Out of Virtual Threads with Structured Task Scopes and Scoped Values

Tue, 23 Dec 2025 07:00:01 +0000

With Java 21, the Java platform completely reinvented how threads work by introducing virtual threads alongside traditional platform threads.
Virtual threads let us create millions of concurrent tasks without worrying about creation time or memory usage. This makes it possible to handle vastly more requests than before, but it doesn’t solve every problem that once led developers to reactive programming.

In this article, we’ll explore how StructuredTaskScope and ScopedValue, two powerful features that complement virtual threads, help us write safer, faster, and more maintainable concurrent code.

More Action, More Overview

Tue, 22 Jul 2025 07:00:01 +0000

Java applications have to contend with various concurrency problems. There is a solution here with new constructs.

Modern Java

Tue, 17 Jun 2025 07:00:02 +0000

With Java’s adoption of a six-month release cycle, new features are being introduced to the language rapidly. This article will explore the latest enhancements from Java versions 21 to 24. Our focus will be on language-specific changes, excluding updates to the JVM. Additionally, we will not cover the Foreign Functions and Memory API, which serves as a modern and safer alternative to JNI.

I would categorize the changes made to the language into three groups:

Structured concurrency

Fri, 18 Apr 2025 07:00:03 +0000

Structured Concurrency was the second delivery that came out of Project Loom. It was first introduced in Java 19 as a preview API. It aimed to simplify multithreaded programming by treating multiple tasks running in different threads as a single unit of work, thereby streamlining makes the code more readable, streamlining error handling, improving reliability, and enhancing observerability.

In this article, we will look at:

Look at what structured concurrency is.
Look at an example using structured concurrency.
Dive into the underlying API with StructuredTaskScope.

What is Structured Concurrency

Structured concurrency allows developers to reason about concurrent code by defining precise points where execution splits into multiple tasks and where those tasks subsequently merge. It brings the same level of organization to concurrency that for loops and if branches bring to structured programming. It achieves this by restricting the lifespan of concurrent operations to specific scopes. Similar to how variables within a if statement in structured programming are bound to that block, concurrent operations within a structured scope are terminated upon exiting that scope. This ensures that threads do not linger, preventing memory leaks and wasted CPU resources.