Anticipated features like structured concurrency, value object storage improvements, and string templates may accompany these new capabilities.
Java Development Kit (JDK) 21 officially launched on September 19, 2023, setting the stage for the anticipated JDK 22, which is scheduled for release on March 19, 2024. This next iteration promises a host of new capabilities aimed at enhancing Java’s functionality and developer experience. Among the potential features are structured concurrency, computed constants, and an improved class-file API, each designed to address specific programming challenges.
JDK 22 is positioned as a short-term release, receiving six months of official support from Oracle. However, various organizations may opt to extend this support, depending on their needs. Although the OpenJDK webpage has yet to confirm specific features for JDK 22, several candidates are under consideration, including enhancements previously introduced in JDK 21. One notable feature is structured concurrency, which simplifies concurrent programming by allowing tasks to be grouped and managed as a single unit, making it easier to handle complex threading scenarios.
Another intriguing possibility is the Shenandoah garbage collector, which was initially intended for inclusion in JDK 21 but was ultimately removed. This low-pause time collector is designed to minimize application pauses during garbage collection, making it a valuable tool for latency-sensitive applications. Developers interested in exploring early builds can access them at jdk.java.net.
In addition to these features, JDK 22 may introduce a preview of a class-file API. This standard API would facilitate the parsing, generation, and transformation of Java class files, streamlining processes that developers regularly encounter. Another proposed feature is computed constants, which serve as immutable value holders initialized only once, thereby enhancing performance and reliability in applications.
Further enhancements could include value object storage improvements, which aim to allow more aggressive inlining of value objects. This is achieved through non-atomic and null-restricted storage, enabling better memory management. Additionally, the inclusion of integrity and strong encapsulation measures will ensure that APIs cannot inadvertently breach encapsulation boundaries without explicit user consent, thus safeguarding application integrity.
Lastly, JDK 22 may preview statements before super() in constructors, allowing developers to place initialization logic more naturally before invoking this() or super(). Alongside these features, ongoing preparations to restrict Java Native Interface (JNI) usage will support integrity-by-default, preparing for a future where JNI’s capabilities may be limited. The anticipated string templates, which pair literal text with embedded expressions, are expected to further simplify string handling in Java. Overall, JDK 22 promises to build upon the foundation laid by JDK 21, introducing features that cater to the evolving needs of the Java development community.