JEP 526 Simplifies Deferred Initialization Ahead of JDK 26

"JEP 526, Lazy Constants (Second Preview), has been completed with a second preview, including changes after the first round of preview, namely JEP 502, Stable Values (Preview), for JDK 26. Formerly known as Stable Values, this feature introduces the concept of computed constants, which are immutable value holders initialized at most once. This provides the performance and safety benefits of final fields while offering greater flexibility in the timing of initialization."

"Revisions for this JEP include: changing the name from Stable Values to Lazy Constants, as the new name better captures the intent of a high-level use case and enhances discoverability. The earlier Stable Values API exposed several low-level operations, such as , , and , which provided fine-grained control over initialization. According to the proposal, these operations were difficult to justify and often encouraged patterns that ran counter to the API's intended purpose."

"JEP 526 replaces these mechanisms with a simpler, more ergonomic class, java.lang.LazyConstant<T>, which supports only factory-based initialization. The renaming clarifies the intent: instead of focusing on "stability via low-level control," the new design emphasizes laziness coupled with immutability. Developers can now express deferred initialization without resorting to ad-hoc patterns like double-checked locking, holder classes, or nullable fields. Using the new API, a lazy constant can be defined by providing a supplier function. The computed value is cached after the first access and never changes again."

JEP 526, Lazy Constants (Second Preview), renames and refines the earlier Stable Values concept for JDK 26. The feature introduces computed constants as immutable value holders that are initialized at most once and provide the performance and safety benefits of final fields while allowing deferred initialization. The low-level Stable Values API exposed operations that encouraged counterproductive patterns and were hard to justify. The new API replaces those mechanisms with java.lang.LazyConstant<T>, a simpler, ergonomic class supporting only factory-based initialization. Lazy constants accept a supplier function, cache the computed value on first access, and never change thereafter. Common lazy idioms like double-checked locking, holder classes, and nullable fields are no longer necessary.

Read at InfoQ