JDK 24 is in Rampdown Phase One, Explore its features

JDK 24 is in Rampdown Phase One. The overall feature is frozen. The main line repository is forked in to stabilization repository. Stabilization branch will accept bug fix and no more new features. GA for JDK 24 will be around March 2025.

Year on year, Java is getting mature and JDK team is trying to reduce the startup time and also developer friendly platform for young developers. Let's explore its feature, what's there in JDK 24.

404: Generational Shenandoah (Experimental)

Enhance the Shenandoah garbage collector with experimental generational collection capabilities to improve sustainable throughput, load-spike resilience, and memory utilization. The goal is to reduce CPU and memory without scarificing low GC pauses.

 

450: Compact Object Headers (Experimental)

HotSpot JVM object headers is between 96 and 128 bits and it has to be reduced down to 64 bits. Objects in Java programs tend to be small and small improvement in reducing object header size will certainly reduce heap size and increase data locality.

 

472: Prepare to Restrict the Use of JNI

The Java Native Interface (JNI) was introduced in JDK 1.1 as the primary means for interoperating between Java code and native code, typically written in C. Any interaction at all between Java code and native code is risky because it can compromise the integrity of applications and of the Java Platform. A warning will be issued in using JNI and Foreign Function & Memory (FFM) API. Application developers can selectively enabling these interfaces when ever required.  

 

475: Late Barrier Expansion for G1

Simplify the implementation of the G1 garbage collector's barriers, which record information about application memory accesses, by shifting their expansion from early in the C2 JIT's compilation pipeline to later.

 

478: Key Derivation Function API (Preview)

Introduce an API for Key Derivation Functions (KDFs), which are cryptographic algorithms for deriving additional keys from a secret key and other data. key derivation function (KDF) is a cryptographic algorithm that derives one or more secret keys from a secret value or from a passphrase.  A KDF allows keys to be created in a manner that is both secure and reproducible by two parties sharing knowledge of the inputs. 

 

479: Remove the Windows 32-bit x86 Port

Remove the source code and build support for the Windows 32-bit x86 port. The port was already deprecated in JDK 21.

 

483: Ahead-of-Time Class Loading & Linking

Improve startup time by exploiting the fact that most applications start up in roughly the same way every time they run. Extend the HotSpot JVM to support an ahead-of-time cache which can store classes after reading, parsing, loading, and linking them. Once a cache is created for a specific application, it can be re-used in subsequent runs of that application to improve startup time.

 

484: Class-File API

Provide a standard API for parsing, generating, and transforming Java class files. Parsing, generating, and transforming class files is ubiquitous because it allows independent tools and libraries to examine and extend programs without jeopardizing the maintainability of source code.

 

485: Stream Gatherers

Enhance the Stream API to support custom intermediate operations. This will allow stream pipelines to transform data in ways that are not easily achievable with the existing built-in intermediate operations.

 

486: Permanently Disable the Security Manager

The Security Manager has been rarely used to secure server side code and it is costly to maintain. It is already deprecated in JDK 17 and it will be disabled in this release and it will be remvoed in future release.

 

487: Scoped Values (Fourth Preview)

Introduce scoped values, which enable a method to share immutable data both with its callees within a thread, and with child threads. Scoped values are easier to reason and better than thread-local variables. 

488: Primitive Types in Patterns, instanceof, and switch (Second Preview)

Enhance pattern matching by allowing primitive types in all pattern contexts, and extend instanceof and switch to work with all primitive types. Enhance the instanceof and switch constructs to support primitive type patterns as top level patterns.

489: Vector API (Ninth Incubator)

Introduce an API to express vector computations that reliably compile at runtime to optimal vector instructions on supported CPU architectures, thus achieving performance superior to equivalent scalar computations. Vector operations express a degree of parallelism that enables more work to be performed in a single CPU cycle and thus can result in significant performance gains. For example, given two vectors, each containing a sequence of eight integers (i.e., eight lanes), the two vectors can be added together using a single hardware instruction.

490: ZGC: Remove the Non-Generational Mode

Maintaining non-generational ZGC slows the development of new features and it is better to remove the non-generational mode of the Z Garbage Collector (ZGC).

 

491: Synchronize Virtual Threads without Pinning

To run code in a virtual thread, the JDK's scheduler assigns the virtual thread for execution on a platform thread by mounting the virtual thread on the platform thread. This makes the platform thread become the carrier of the virtual thread. Later, after running some code, the virtual thread can unmount from its carrier. At that point the platform thread is released so that the JDK's scheduler can mount a different virtual thread on it, thereby making it a carrier again. There are few scenario where synchronized methods blocks the virtual thread and which inturn blocks platform thread.

Improve the scalability of Java code that uses synchronized methods and statements and unmount the virtual thread from platform thread. 

 

492: Flexible Constructor Bodies (Third Preview)

In constructors in the Java programming language, allow statements to appear before an explicit constructor invocation, i.e., super(..) or this(..). The statements cannot reference the instance under construction, but they can initialize its fields. Initializing fields before invoking another constructor makes a class more reliable when methods are overridden.

 

493: Linking Run-Time Images without JMODs

Reduce the size of the JDK by approximately 25% by enabling the jlink tool to create custom run-time images without using the JDK's JMOD files. 

 

494: Module Import Declarations (Second Preview)

Enhance the Java programming language with the ability to succinctly import all of the packages exported by a module. Avoid the noise of multiple type-import-on-demand declarations (e.g., import com.foo.bar.*) when using diverse parts of the API exported by a module. Simplify the reuse of modular libraries by allowing entire modules to be imported at once.

 

495: Simple Source Files and Instance Main Methods (Fourth Preview)

Evolve the Java programming language so that beginners can write their first programs without needing to understand language features designed for large programs. Make it easy for new developers.

 

496: Quantum-Resistant Module-Lattice-Based Key Encapsulation Mechanism

Enhance the security of Java applications by providing an implementation of the quantum-resistant Module-Lattice-Based Key-Encapsulation Mechanism (ML-KEM). Key encapsulation mechanisms (KEMs) are used to secure symmetric keys over insecure communication channels using public key cryptography.

 

497: Quantum-Resistant Module-Lattice-Based Digital Signature Algorithm

Enhance the security of Java applications by providing an implementation of the quantum-resistant Module-Lattice-Based Digital Signature Algorithm (ML-DSA). Digital signatures are used to detect unauthorized modifications to data and to authenticate the identity of signatories.

 

498:  Warn upon Use of Memory-Access Methods in sun.misc.Unsafe

A warning will be issued at run time on the first occasion that any memory-access method in sun.misc.Unsafe is invoked. All of these unsupported methods were terminally deprecated in JDK 23. They have been superseded by standard APIs, namely the VarHandle API (JEP 193, JDK 9) and the Foreign Function & Memory API (JEP 454, JDK 22).

 

499: Structured Concurrency (Fourth Preview)

Simplify concurrent programming by introducing an API for structured concurrency. Structured concurrency treats groups of related tasks running in different threads as a single unit of work, thereby streamlining error handling and cancellation, improving reliability, and enhancing observability.