Java Development Kit (JDK) 23 has officially been released, bringing with it a host of exciting new features and improvements to the Java programming language. This update introduces a variety of changes, including previews of module import declarations, stream gatherers, structured concurrency, and scoped values, as well as a new class-file API. However, one significant change in JDK 23 is the deprecation of memory access methods in the sun.misc.Unsafe class, signaling a shift towards safer, more standardized alternatives. These updates aim to enhance the functionality and performance of Java, with thousands of smaller improvements and bug fixes included in the release.
JDK 23 includes several notable previews, such as scoped values, structured concurrency, and implicitly declared classes and instance methods. The second previews bring in flexible constructor bodies, stream gatherers, and an updated class-file API. Additionally, this release introduces module import declarations, Markdown documentation comments, and a new iteration of the vector API. One of the more significant innovations is the preview of primitive types in patterns, instanceof, and switch, which provides enhanced support for primitive data types in Java’s pattern matching features.
In contrast to JDK 21, which is a Long-Term Support (LTS) release, JDK 23 is a non-LTS version, which means it will only receive six months of support from Oracle. This shorter support lifecycle emphasizes the focus on innovation and experimentation, as new features are introduced more rapidly. However, as a non-LTS release, developers will need to stay agile and plan for the next JDK updates when adopting JDK 23 in production environments.
Scoped values, one of the highlights of JDK 23, aim to improve the management of immutable data within Java applications. Building on previous previews in JDK 21 and JDK 22, scoped values allow for easier sharing of data between methods, threads, and child threads. This reduces the complexity compared to using thread-local values and offers better space and time efficiency, especially when working with virtual threads and structured concurrency. The introduction of a new functional interface in the ScopedValue.callWhere method further improves usability by enabling the Java compiler to infer whether a checked exception might be thrown.
One of the most crucial changes in JDK 23 is the deprecation of memory access methods in the sun.misc.Unsafe class. These methods, once a staple for low-level memory manipulation, are being phased out in favor of more modern, supported APIs like the VarHandle API and the Foreign Function and Memory API. The goal is to make applications more future-proof by encouraging developers to transition to safer and more standardized memory access mechanisms. While sun.misc.Unsafe is not being removed entirely, its memory access methods will be deprecated and removed in future releases, marking an important step in Java’s evolution towards better memory safety and improved developer practices.