The upcoming Java Development Kit (JDK) 24 is approaching its official release, scheduled for March 18. Now in the release candidate phase, JDK 24 introduces a total of 24 enhancements, significantly surpassing JDK 23, which included only 12 features. This version brings improvements in concurrency, security, memory management, and performance optimization.

Recent Additions and Notable Improvements

JDK 24 incorporates multiple noteworthy upgrades, such as:

• Runtime warnings when using memory-access methods in sun.misc.Unsafe.
• A fourth preview of structured concurrency, refining concurrent programming.
• Deprecation of the 32-bit x86 port, signaling its removal in future versions.
• Enhancements in security, including quantum-resistant cryptographic mechanisms.
• Performance optimizations across various JVM components.

Structured Concurrency: Streamlining Parallel Processing

Returning for another preview, structured concurrency introduces an API aimed at simplifying concurrent programming. This concept treats related tasks within different threads as a unified operation, improving error handling, reliability, and performance. By reducing issues such as thread leaks and delays in cancellation, this API enhances the overall observability of concurrent applications.

Security Enhancements: Preparing for Quantum Computing

JDK 24 introduces two cryptographic mechanisms resistant to quantum computing threats:

• ML-KEM (Module-Lattice Key Encapsulation Mechanism): Strengthens the encryption of keys over unsecured networks.
• ML-DSA (Module-Lattice Digital Signature Algorithm): Protects data integrity and validates digital identities.

These additions align Java’s security model with emerging cryptographic standards, ensuring resilience against evolving cybersecurity threats.

Advancements in JVM and Memory Management

• Flexible Constructor Bodies: Developers gain increased control over object initialization by structuring constructor logic into distinct prologue and epilogue phases.
• Ahead-of-Time (AOT) Class Loading and Linking: Optimizes startup performance by preloading class structures based on previous executions.
• Removal of Windows 32-bit x86 Support: Following its deprecation in JDK 21, the outdated 32-bit x86 architecture for Windows is now fully phased out.
• Compact Object Headers: Reduces memory consumption and enhances runtime efficiency by shrinking object headers within the HotSpot JVM.

Enhancements in Garbage Collection and Stream Processing

• Generational Shenandoah GC: Introduces a generational mode to boost garbage collection efficiency while maintaining backward compatibility.
• Stream Gatherers: Expands Java’s Stream API with custom intermediate operations for enhanced data transformations.
• ZGC Improvements: The non-generational mode of the Z Garbage Collector (ZGC) is being removed to streamline development and optimize performance.

Improved Language Features and APIs

• Primitive Types in Patterns, instanceof, and switch: This update extends Java’s pattern matching capabilities to primitive types, making type checks and data handling more intuitive.
• Vector API Finalization: After multiple incubation and preview phases since JDK 16, the Vector API is now being finalized, enabling highly optimized vectorized computations on modern CPU architectures.
• Class-File API: Standardizes parsing, generating, and modifying Java class files, replacing the previous reliance on third-party libraries.
• Module Import Declarations: Simplifies modular programming by allowing entire module imports without requiring code modifications.

What to Expect in Future Releases

JDK 24 is classified as a short-term release, meaning it will receive official support for only six months, similar to JDK 23. The next major long-term support (LTS) release, JDK 25, is planned for September. Early access builds for JDK 24 are already available at jdk.java.net, allowing developers to explore and test the new features ahead of the official launch.

Conclusion

With significant advancements in concurrency, security, memory management, and garbage collection, JDK 24 marks a substantial step forward for Java developers. Although not an LTS release, its improvements provide a glimpse into the long-term evolution of the Java ecosystem. Developers are encouraged to experiment with these new features and prepare for their broader adoption in future versions.