Java 24: Scoped Values (Fourth Preview)

What’s New in Java 24: JEP 487 – Scoped Values (Fourth Preview)

Java 24 brings an exciting enhancement under JEP 487: Scoped Values (Fourth Preview). This feature aims to solve a long-standing problem faced by Java developers—passing context information like user session, transaction IDs, or request metadata through multiple layers of code, even when that information isn’t needed by the core business logic.

Let’s explore what Scoped Values are, why they matter, and how they improve over existing constructs like ThreadLocal.

The Problem with Passing Context

In many Java applications—especially in web development—we often see a pattern where application code invokes framework code and vice versa. For example, your controller might call a service method, passing along request and response objects. Similarly, the framework might call your code to retrieve user information or handle transactions.

Frameworks frequently need a context object to carry important metadata like:

• transactionId
• userId
• session details

However, this context often needs to be passed manually through several layers of methods—even when those methods don’t use it directly. This leads to boilerplate code and tightly coupled method signatures.

Why ThreadLocal Isn’t the Ideal Solution

Traditionally, developers have used ThreadLocal variables to avoid passing context explicitly. While this helps in reducing parameter clutter, it introduces its own set of problems:

• ThreadLocal variables are mutable, meaning any thread can modify the value—intentionally or by accident.
• This mutability leads to hard-to-debug issues in concurrent environments.
• It does not work well with virtual threads, which are becoming increasingly popular in the Java ecosystem.

Enter Scoped Values

ScopedValue<T> is a new construct designed to replace ThreadLocal in many scenarios, particularly when you need read-only context propagation.

Key benefits of ScopedValue:

• Immutable once bound
• Safer in concurrent and virtual thread environments
• Clear and structured lifecycle

ScopedValue Example

Here’s a simple example to demonstrate how ScopedValue works:

javaCopyEditimport java.lang.ScopedValue;

public class ScopedValueDemo {
    static final ScopedValue<String> USER_ID = ScopedValue.newInstance();

    public static void main(String[] args) {
        ScopedValue.where(USER_ID, "user123").run(() -> {
            processRequest();
        });
    }

    public static void processRequest() {
        System.out.println("Processing request for user: " + USER_ID.get());
        serviceMethod();
    }

    public static void serviceMethod() {
        System.out.println("Service method sees user: " + USER_ID.get());
    }
}

Explanation

In this example:

• ScopedValue<String> USER_ID is declared and bound to "user123" inside a scope.
• The call to ScopedValue.where(...).run(...) creates a new scope in which USER_ID is accessible.
• Both processRequest and serviceMethod can read the scoped value, but cannot modify it.

This eliminates the need to pass userId as a parameter through multiple methods and ensures thread safety and immutability, especially beneficial when using virtual threads.