Release notes for Red Hat build of OpenJDK 25.0.1

Red Hat build of OpenJDK 25 includes the following new language features.

Flexible constructor bodies

In Java constructors, Red Hat build of OpenJDK 25 allows statements to appear before the explicit constructor invocations, super(…​) and this(…​). These statements cannot reference the instance that is under construction, but they can initialize its fields. This ability to initialize fields before invoking another constructor makes a class more reliable when methods are overridden.

For example, in earlier releases, you could only call a statement after the constructor invocation as follows:

 void myMethod(int a, int b) {
    super(b);
    this.a = a;
  }

In this release, you can call the statement before the constructor invocation. Based on the following example, it means that a is set when the super constructor and any methods that it calls are running:

  void myMethod(int a, int b) {
    this.a = a;
    super(b);
  }

This feature was initially introduced as a preview feature named Statements before super(…​) in OpenJDK 22 (JEP 447). A second preview was introduced in OpenJDK 23 (JEP 482) with support for allowing fields to be initialized before invoking another constructor. A third preview was introduced in OpenJDK 24 (JEP 492).

For more information, see the following JEPs:

Unnamed patterns and variables

In Red Hat build of OpenJDK 25, Java includes support for unnamed patterns, which match a record component without stating the component’s name or type. In this release, Java also now supports unnamed variables, which can be initialized but not used. Unnamed patterns and unnamed variables are both denoted by an underscore (_) character.

This feature was initially introduced as a preview feature in OpenJDK 21 (JEP 443), and it was finalized in OpenJDK 22 (JEP 456).

For more information, see the following JEPs:

Primitive types in patterns, instanceof, and switch (Preview)

Red Hat build of OpenJDK 25 adds a preview feature to enhance pattern matching by allowing primitive type patterns in all pattern contexts. This preview feature also extends the instanceof operator and switch statement to work with all primitive types.

For more information, see the following JEPs:

Module import declarations

In Red Hat build of OpenJDK 25, Java includes support for succinctly importing all of the packages that are exported by a module. This enhancement simplifies the reuse of modular libraries, but it does not require the code that is performing the import to be in a module itself.

This feature was initially introduced as a preview feature in OpenJDK 23 (JEP 476) with a second preview in OpenJDK 24 (JEP 494).

For more information, see the following JEPs:

Red Hat build of OpenJDK 25 includes the following new library features.

Foreign function and memory API

Red Hat build of OpenJDK 25 includes a Foreign function and memory (FFM) API that Java programs can use to interoperate with code and data outside of the Java runtime. A foreign function is code outside the Java virtual machine (JVM), and foreign memory is memory that is not managed by the JVM. By efficiently invoking foreign functions and by safely accessing foreign memory, this API allows Java programs to call native libraries and process native data without having to rely on the Java Native Interface (JNI).

This feature was initially introduced in incubation in OpenJDK 17 (JEP 412) as an evolution of the Foreign Memory Access API and Foreign Linker API. It had a second round of incubation in OpenJDK 18 (JEP 419), and it was then introduced as a preview feature in OpenJDK 19 (JEP 424), with a second and third preview in OpenJDK 20 (JEP 434) and OpenJDK 21 (JEP 442), respectively. It was finalized in OpenJDK 22 (JEP 454).

For more information, see the following JEPs:

Warning about JNI usage and consistent warnings from FFM API

Red Hat build of OpenJDK 25 issues warnings about use of the Java Native Interface (JNI). This release also ensures that the Foreign Function & Memory (FFM) API issues warnings in a consistent manner. These warnings aim to prepare developers for a future release that uniformly restricts JNI and the FFM API to ensure integrity by default. Application developers can avoid both current warnings and future restrictions by selectively enabling these interfaces, if necessary, by using the ‑‑enable‑native‑access command-line option.

For more information, see JEP 472: Prepare to Restrict the Use of JNI.

ClassFile API

Red Hat build of OpenJDK 25 includes a ClassFile API, which is a standard API for parsing, generating, and transforming Java class files.

This API was introduced as a preview feature in OpenJDK 22 (JEP 457) with a second preview in OpenJDK 23 (JEP 466). It was finalized in OpenJDK 24 (JEP 484).

For more information, see the following JEPs:

Vector API (Incubator feature)

Red Hat build of OpenJDK 25 includes a Vector API, which is used to express vector computations that reliably compile at runtime to optimal vector hardware instructions on supported CPU architectures. These optimal instructions achieve performance levels that are superior to equivalent scalar computations.

This API is an incubation feature that was initially introduced in OpenJDK 16, and which has subsequently had nine additional rounds of incubation up to OpenJDK 25.

For more information, see the following JEPs:

Stream gatherers

Red Hat build of OpenJDK 25 includes an enhancement to the Stream API to support custom intermediate operations. This enhancement allows stream pipelines to transform data in ways that are not easily achieved with the existing built-in intermediate operations.

This enhancement was introduced as a preview feature in OpenJDK 22 (JEP 461) with a second preview in OpenJDK 23 (JEP 473). It was finalized in OpenJDK 24 (JEP 485).

For more information, see the following JEPs:

Structured concurrency (Preview)

Red Hat build of OpenJDK 25 adds an API for structured concurrency as a preview feature to help simplify multithreaded programming. Structured concurrency treats multiple tasks that are running in different threads as a single unit of work, which helps to streamline error handling and cancellation, improve reliability, and enhance observability.

This API was initially introduced in incubation in OpenJDK 19 (JEP 428) with a second round of incubation in OpenJDK 20 (JEP 437). It then became a preview feature in OpenJDK 21 (JEP 453) with an additional four preview rounds up to OpenJDK 25.

For more information, see the following JEPs:

Compact source files and instance main methods

In Red Hat build of OpenJDK 25, beginners in the Java programming language can write their first programs without needing to understand language features that are designed for large programs. Instead of using a separate dialect of Java, beginners can write streamlined declarations for single-class programs and seamlessly expand their programs to use more advanced features as their skills grow. Experienced developers can similarly write small programs succinctly, without the need for constructs intended for large-scale programming.

This feature was initially introduced as a preview feature named Unnamed Classes and Instance Main Methods in OpenJDK 21 (JEP 445). Due to the move away from unnamed classes to an implicitly declared name chosen by the host system, it had a second preview that was renamed Implicitly Declared Classes and Instance Main Methods in OpenJDK 22 (JEP 463). It had a third preview in OpenJDK 23 (JEP 477). A fourth preview that was renamed Simple Source Files and Instance Main Methods was introduced in OpenJDK 24 (JEP 495) with new terminology but no additional changes.

For more information, see the following JEPs:

Scoped values

Red Hat build of OpenJDK 25 includes a scoped values feature, which enables the sharing of immutable data within and across threads. Scoped values are preferable to thread-local variables, especially when using large numbers of virtual threads.

This feature was initially introduced in incubation in OpenJDK 20 (JEP 429). It became a preview feature in OpenJDK 21 (JEP 446) with an additional three preview rounds in OpenJDK 22 (JEP 464), OpenJDK 23 (JEP 481), and OpenJDK 24 (JEP 487).

For more information, see the following JEPs:

Key derivation function API

Red Hat build of OpenJDK 25 includes an API for Key Derivation Functions (KDFs). KDFs are cryptographic algorithms for deriving additional keys from a secret key and other data.

This API was initially introduced as a preview feature in OpenJDK 24 (JEP 478).

For more information, see the following JEPs:

Quantum-resistant module-lattice-based key encapsulation mechanism

Red Hat build of OpenJDK 25 includes an implementation of the quantum-resistant Module-Lattice-Based Key-Encapsulation Mechanism (ML-KEM), which helps to enhance the security of Java applications. Key encapsulation mechanisms (KEMs) are used to secure symmetric keys over insecure communication channels by using public key cryptography. ML-KEM is designed to be secure against future quantum computing attacks. It has been standardized by the United States National Institute of Standards and Technology (NIST) in FIPS 203.

For more information, see JEP 496: Quantum-Resistant Module-Lattice-Based Key Encapsulation Mechanism.

Quantum-resistant module-lattice-based digital signature algorithm

Red Hat build of OpenJDK 25 includes an implementation of the quantum-resistant Module-Lattice-Based Digital Signature Algorithm (ML-DSA), which helps to enhance the security of Java applications. Digital signatures are used to detect unauthorized modifications to data and to authenticate the identity of signatories. ML-DSA is designed to be secure against future quantum computing attacks. It has been standardized by the United States NIST in FIPS 204.

For more information, see JEP 497: Quantum-Resistant Module-Lattice-Based Digital Signature Algorithm.

PEM encodings of cryptographic objects (Preview)

Red Hat build of OpenJDK 25 adds an API for Privacy-Enhanced Mail (PEM) encodings of cryptographic objects as a preview feature. This API is used for encoding objects that represent cryptographic keys, certificates, and certificate revocation lists into the PEM transport format. It is also used for decoding from that format back into objects.

For more information, see JEP 470: PEM Encodings of Cryptographic Objects (Preview).

Stable values (Preview)

Red Hat build of OpenJDK 25 adds an API for stable values as a preview feature. Stable values are objects that hold immutable data. The JVM treats these values as constants, enabling the same performance optimizations that are enabled by declaring a field with the final keyword. However, due to the timing of their initialization, stable values offer greater flexibility compared to final fields.

For more information, see JEP 502: Stable Values (Preview).

Red Hat build of OpenJDK 25 includes the following virtual machine enhancements.

Region pinning for G1 garbage collector

Red Hat build of OpenJDK 25 includes region pinning in the G1 garbage collector to help reduce latency. This enhancement means that garbage collection does not need to be disabled during JNI critical regions.

For more information see, JEP 423: Region Pinning for G1.

ZGC uses generational mode by default

In Red Hat build of OpenJDK 25, the Z garbage collector (ZGC) uses generational mode by default. This supersedes the behavior in earlier releases where ZGC used the now removed non-generational mode by default.

For more information, see the following JEPs:

Late barrier expansion for G1 garbage collector

Red Hat build of OpenJDK 25 simplifies the implementation of the G1 garbage collector’s barriers, which record information about application memory accesses. This release shifts the expansion of these barriers from early in the C2 just-in-time (JIT) compilation pipeline to later.

For more information, see JEP 475: Late Barrier Expansion for G1.

Ahead-of-time class loading and linking

Red Hat build of OpenJDK 25 improves the startup time for applications by making an application’s classes instantly available in a loaded and linked state when the HotSpot JVM starts. In this situation, an application is monitored during one run, and the loaded and linked forms of all of the application’s classes are then stored in a cache for use in subsequent runs. This feature also provides a foundation for future improvements in startup and warm-up times.

The use of this feature involves a two-step process:

As shown in the preceding steps, you can use the ‑‑XX:AOTCacheOutput option to handle both the training run and creation of the cache in a single step by using a temporary configuration file. In this situation, you can use the JDK_AOT_VM_OPTIONS environment variable to pass options for cache creation without affecting the training run.

For more information, see the following JEPs:

Ahead-of-time class method profiling

Red Hat build of OpenJDK 25 improves the warm-up time for applications by making method-execution profiles from a previous run of an application instantly available when the HotSpot JVM starts. This feature allows the JIT compiler to generate native code immediately at application startup instead of having to wait for profiles to be collected.

For more information, see JEP 515: Ahead-of-Time Method Profiling.

Synchronize virtual threads without pinning

Red Hat build of OpenJDK 25 improves the scalability of Java code that uses synchronized methods and statements. The JDK now arranges for virtual threads that block in such constructs to release their underlying platform threads for use by other virtual threads. This feature eliminates almost all cases of virtual threads being pinned to platform threads, which might otherwise severely restrict the number of available virtual threads for handling an application’s workload.

For more information, see JEP 491: Synchronize Virtual Threads without Pinning.

Compact object headers

Red Hat build of OpenJDK 25 can optionally reduce the size of object headers in the HotSpot JVM from between 96 and 128 bits down to 64 bits on 64-bit architectures. This feature helps to reduce heap size, improve deployment density, and increase data locality. You can enable this feature by using the ‑XX:+UseCompactObjectHeaders option.

This change was initially introduced as an experimental feature in OpenJDK 24 (JEP 450) that also required the ‑XX:+UnlockExperimentalVMOptions option.

For more information, see the following JEPs:

Generational Shenandoah garbage collection

Red Hat build of OpenJDK 25 enhances the Shenandoah garbage collector with generational collection support that helps to improve sustainable throughput, load-spike resilience, and memory utilization. You can enable this feature by using the ‑XX:ShenandoahGCMode=generational option.

This change was initially introduced as an experimental feature in OpenJDK 24 (JEP 404) that also required the ‑XX:+UnlockExperimentalVMOptions option.

For more information, see the following JEPs:

JFR cooperative sampling

Red Hat build of OpenJDK 25 improves the stability of the JDK Flight Recorder (JFR) when it asynchronously samples Java thread stacks. This is achieved by walking call stacks at safepoints only, while minimizing safepoint bias.

For more information, see JEP 518: JFR Cooperative Sampling.

JFR method timing and tracing

Red Hat build of OpenJDK 25 extends the JFR with support for method timing and tracing through bytecode instrumentation.

For more information, see JEP 520: JFR Method Timing & Tracing.

JFR CPU-time profiling (Experimental)

Red Hat build of OpenJDK 25 adds an experimental feature to allow the JFR to capture more accurate CPU-time profiling information on Linux platforms. Because this is an experimental feature, the associated JFR events are tagged with @Experimental annotation.

Unlike other experimental virtual machine features, you do not need to explicitly enable this feature by using the XX:+UnlockExperimentalVMOptions option.

For more information, see JEP 509: JFR CPU-Time Profiling (Experimental).

Red Hat build of OpenJDK 25 includes the following tooling enhancements.

Application launcher support for multi-file source code programs

In Red Hat build of OpenJDK 25, the java application launcher is able to run a program that is supplied as multiple Java source code files. This helps to make the transition from small programs to larger programs more gradual, which gives developers flexibility in deciding whether and when to configure a build tool.

For more information, see JEP 458: Launch Multi-File Source-Code Programs.

Javadoc support for markdown documentation comments

In Red Hat build of OpenJDK 25, Javadoc authors can write documentation comments in markdown language rather than solely in a mixture of HTML and JavaDoc @<metadata> tags.

For more information, see JEP 467: Markdown Documentation Comments.

Red Hat build of OpenJDK 25 includes the following bug fix.

Fix for issue caused by changing type of java.time month and day fields to byte

In the initial release of Red Hat build of OpenJDK 25, when attempting to read serialized Class objects that were created in earlier OpenJDK versions for some of the java.time classes, a failure occurred with an InvalidClassException. Similarly, java.time Class objects that were serialized with Red Hat build of OpenJDK 25 could not be read by older OpenJDK versions.

This issue was introduced in the initial release of Red Hat build of OpenJDK 25, which changed the month and day fields in java.time classes to the byte type.

Red Hat build of OpenJDK 25.0.2 resolves this issue by reverting to the earlier behavior that was available before the introduction of Red Hat build of OpenJDK 25. This fix also helps to restore compatibility between Red Hat build of OpenJDK 25 and older versions.

See JDK-8367031 (JDK Bug System).

The following pre-existing feature has been removed in Red Hat build of OpenJDK 25.0.1.

AffirmTrust root CA certificates removed

From Red Hat build of OpenJDK 25.0.1 onward, the cacerts truststore no longer includes the following AffirmTrust root certificates:

See JDK-8361212 (JDK Bug System).