With the release of Java 25, scoped values come out of preview and enter the mainstream as one of the most impactful improvements for concurrency and context propagation in Java\u2019s recent history. Designed to address the perennial issue of safely sharing context across method chains and threads, scoped values deliver a clean, immutable, and automatically bounded solution that dethrones the error-prone ThreadLocal for most scenarios.<\/p>\n
For years, Java developers have used ThreadLocal to pass data down a call stack\u2014such as security credentials, logging metadata, or request-specific state. While functional, ThreadLocal suffers from lifecycle ambiguity, memory leaks, and incompatibility with lightweight virtual threads. Scoped values solve these problems by making context propagation explicit in syntax, immutable in nature, and automatic in cleanup.<\/p>\n
Imagine code execution as moving through a series of rooms, each with its unique lighting. A scoped value is like setting the lighting for a room\u2014within its boundaries, everyone sees the same illumination (data value), but outside those walls, the setting is gone. Each scope block clearly defines where the data is available and safe to access.<\/p>\n
Scoped values require two ingredients:<\/p>\n
ScopedValue<\/code> as a static final field, usually parameterized by the intended type.<\/li>\n- Binding:<\/strong> Use
ScopedValue.where()<\/code> to create an execution scope where the value is accessible.<\/li>\n<\/ul>\nInside any method called within the binding scope\u2014even dozens of frames deep\u2014the value can be retrieved by .get()<\/code>, without explicit parameter passing.<\/p>\nExample: Propagating User Context Across Methods<\/h2>\n\/\/ Declare the scoped value\nprivate static final ScopedValue<String> USERNAME = ScopedValue.newInstance();\n\npublic static void main(String[] args) {\n ScopedValue.where(USERNAME, "alice").run(() -> entryPoint());\n}\n\nstatic void entryPoint() {\n printCurrentUser();\n}\n\nstatic void printCurrentUser() {\n System.out.println("Current user: " + USERNAME.get()); \/\/ Outputs "alice"\n}<\/code><\/pre>\nIn this sample, USERNAME<\/code> is accessible in any method within the binding scope, regardless of how far it\u2019s called from the entry point.<\/p>\nNested Binding and Rebinding<\/h2>\n
Scoped values provide nested rebinding: within a scope, a method can establish a new nested binding for the same value, which is then available only to its callees. This ensures truly bounded context lifetimes and avoids unintended leakage or overwrites.<\/p>\n
\/\/ Declare the scoped value\nprivate static final ScopedValue<String> MESSAGE = ScopedValue.newInstance();\n\nvoid foo() {\n ScopedValue.where(MESSAGE, "hello").run(() -> bar());\n}\n\nvoid bar() {\n System.out.println(MESSAGE.get()); \/\/ prints "hello"\n ScopedValue.where(MESSAGE, "goodbye").run(() -> baz());\n System.out.println(MESSAGE.get()); \/\/ prints "hello"\n}\n\nvoid baz() {\n System.out.println(MESSAGE.get()); \/\/ prints "goodbye"\n}<\/code><\/pre>\nHere, the value "goodbye" is only visible within the nested scope inside baz<\/code>, while "hello" remains for bar<\/code> outside that sub-scope.openjdk<\/a><\/p>\nThread Safety and Structured Concurrency<\/h2>\n
Perhaps the biggest leap: scoped values are designed for modern concurrency, including Project Loom\u2019s virtual threads and Java's structured concurrency. Scoped values are automatically inherited by child threads launched within the scope, eliminating complex thread plumbing and ensuring correct context propagation.<\/p>\n
\/\/ Declare the scoped value\nprivate static final ScopedValue<String> REQUEST_ID = ScopedValue.newInstance();\n\npublic static void main(String[] args) throws InterruptedException {\n String requestId = "req-789";\n usingVirtualThreads(requestId);\n usingStructuredConcurrency(requestId);\n}\n\nprivate static void usingVirtualThreads(String requestId) {\n try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {\n \/\/ Launch multiple concurrent virtual threads, each with its own scoped value binding\n Future<?> taskA = executor.submit(() ->\n ScopedValue.where(REQUEST_ID, requestId).run(() -> processTask("Task VT A"))\n );\n Future<?> taskB = executor.submit(() ->\n ScopedValue.where(REQUEST_ID, requestId).run(() -> processTask("Task VT B"))\n );\n Future<?> taskC = executor.submit(() ->\n ScopedValue.where(REQUEST_ID, requestId).run(() -> processTask("Task VT C"))\n );\n\n \/\/ Wait for all tasks to complete\n try {\n taskA.get();\n taskB.get();\n taskC.get();\n } catch (Exception e) {\n throw new RuntimeException(e);\n }\n }\n}\n\nprivate static void usingStructuredConcurrency(String requestId) {\n ScopedValue.where(REQUEST_ID, requestId).run(() -> {\n try (var scope = StructuredTaskScope.open()) {\n \/\/ Launch multiple concurrent virtual threads\n scope.fork(() -> {\n processTask("Task SC A");\n });\n scope.fork(() -> {\n processTask("Task SC B");\n });\n scope.fork(() -> {\n processTask("Task SC C");\n });\n\n scope.join();\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n throw new RuntimeException(e);\n }\n });\n}\n\nprivate static void processTask(String taskName) {\n \/\/ Scoped value REQUEST_ID is automatically visible here\n System.out.println(taskName + " processing request: " + REQUEST_ID.get());\n}<\/code><\/pre>\nNo need for explicit context passing\u2014child threads see the intended value automatically.<\/p>\n
Key Features and Advantages<\/h2>\n\n- Immutability:<\/strong> Values cannot be mutated within scope, preventing accidental overwrite and race conditions.<\/li>\n
- Automatic Cleanup:<\/strong> Context disappears at the end of the scope, eliminating leaks.<\/li>\n
- No Boilerplate:<\/strong> No more manual parameter threading across dozens of method signatures.<\/li>\n
- Designed for Virtual Threads:<\/strong> Plays perfectly with Java\u2019s latest concurrency primitives.baeldung+2<\/a><\/li>\n<\/ul>\n
Use Cases<\/h2>\n\n- Securely propagate authenticated user or tracing info in web servers.<\/li>\n
- Pass tenant, locale, metrics, or logger context across libraries.<\/li>\n
- Enable robust structured concurrency with context auto-inheritance.<\/li>\n<\/ul>\n","protected":false},"excerpt":{"rendered":"
With the release of Java 25, scoped values come out of preview and enter the mainstream as one of the most impactful improvements for concurrency and context propagation in Java\u2019s recent history. Designed to address the perennial issue of safely sharing context across method chains and threads, scoped values deliver a clean, immutable, and automatically […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[89],"tags":[],"_links":{"self":[{"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/posts\/1989"}],"collection":[{"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=1989"}],"version-history":[{"count":2,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/posts\/1989\/revisions"}],"predecessor-version":[{"id":2046,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/posts\/1989\/revisions\/2046"}],"wp:attachment":[{"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=1989"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=1989"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=1989"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}