RELEASE NOTES: JDK 24

Single-line Leading /// Dangling Comments Are No Longer Warned About

DocLint in javac/javadoc no longer warns about a /// single-line dangling comment that starts a file. This is to accommodate systems that support a stylized comment on the first line of a source file as a way to "auto-execute" the file.

javac Accepts class Files With Any Number of Entries in RuntimeVisibleParameterAnnotations and RuntimeInvisibleParameterAnnotations Attributes

The Java Virtual Machine Specification is permissive regarding the number of entries of the RuntimeVisibleParameterAnnotations and RuntimeInvisibleParameterAnnotations attributes in the class file format. The javac tool was less permissive, and was rejecting class files that had a different number of entries than javac expected.

With JDK 24, this is fixed, and javac now accepts class files with any number of entries in the RuntimeVisibleParameterAnnotations and RuntimeInvisibleParameterAnnotations attributes. A compile-time warning is produced if the content of the attributes cannot be mapped to the corresponding method's parameters.

HttpClient 100-continue Timeout

java.net.http.HttpClient would previously timeout if a server didn’t respond to a request which included a Expect: 100-Continue header. 
This release updates HttpClient to send the request body if the server doesn’t respond, and brings the implementation in line with RFC 9110

Socket.connect closes the Socket if the connection cannot be established

The connect methods defined by java.net.Socket are now specified, and changed, to close the Socket if the connection cannot be established, or the timeout (if provided) expires before the connection is established.

The behavior in previous JDK releases was to close the underlying socket when a connection could not be established but leave the Socket open. The resulting Socket was "useless" as most methods behaved as if the Socket was closed.

The behavior of the connect methods when invoked with an unresolved InetSocketAddress was unspecified in previous releases. The behavior in JDK 11 and older releases was to close the underlying socket, throw UnknownHostException, but leave the Socket open in a "useless" state. The behavior in JDK 12 to JDK 23 was to throw UnknownHostException without closing the Socket or underlying socket. This case is now specified, and changed, to close the Socket, the underlying socket, and throw UnknownHostException if the connection cannot be established because the address is unresolved.

As part of this change, calling the connect method on a Socket obtained from a SocketChannel will now throw IOException if already connected. This is the specified exception for this scenario. The incorrect behavior in previous releases was to throw AlreadyConnectedException for this case.

java.net.http.HttpClient Is Enhanced To Report HTTP/2 Flow Control Errors To The Server

The java.net.http.HttpClient will now report HTTP/2 flow control errors to the server when they are detected. This is an implementation detail that should be transparent to users of the HttpClient API, but could result in streams being reset or connections being closed if connecting to a non-conformant HTTP/2 server.

Authorization header is removed when a proxy Authenticator is set on HttpClient

ADDITIONAL SYSTEM INFORMATION : Tested on Ubuntu Linux using

openjdk version "17.0.10" 2024-01-16 OpenJDK Runtime Environment (build 17.0.10+7-Ubuntu-122.04.1) OpenJDK 64-Bit Server VM (build 17.0.10+7-Ubuntu-122.04.1, mixed mode, sharing)

A DESCRIPTION OF THE PROBLEM : A customer of CloudBees CI, a product based on Jenkins, reported a critical functional regression when updating from Java 11 to 17. Investigation revealed that an HTTP request posting to a token request endpoint as part of an OpenID Connect authorization flow was missing the Authorization: Bearer … header which is of course mandatory for completing the flow. The regression was found to occur only when a systemwide HTTP proxy was defined, and furthermore only when this proxy required authentication; in this combination of circumstances, the Java 17 HTTP client silently drops the Authorization header (while the same code worked fine in Java 11).

Searching the web turned up JDK-8306745. The code in Jenkins is very similar to the unit test attached there. (https://github.com/jenkinsci/jenkins/pull/8990 touches the relevant code.) I believe that was closed improperly because it is mixing up two unrelated things: authentication to the proxy server and authentication to the origin server. Merely defining an Authenticator whose getPasswordAuthentication returns something for RequestorType.PROXY (suggesting a Proxy-Authorization: Basic …) should have no effect on an Authorization header (especially Bearer!) intended for the origin server. In fact merely calling HttpClient.Builder.authenticator with a no-op Authenticator that always returns null would silently strip any Authorization headers explicitly defined in requests, which seems surprising and counterintuitive.

The problem was especially perverse in the case reported by the CloudBees CI customer because the origin server in this case was explicitly listed among the no-proxy hosts, so ProxySelector.select was returning Proxy.NO_PROXY. (The proxy server was presumably required for unrelated origin servers on the Internet.) Thus calling both .proxy and .authenticator on the builder produces a client which is incapable of making authorized requests even when neither the proxy nor the authenticator were actually active.

The intent of the CONTEXT_RESTRICTED in https://github.com/openjdk/jdk/commit/028f2e14b3550dd1f2a358a2a0aaf83d4a824af0 (JDK-8213189) seems to have been to ensure that user code does not pass headers which are supposed to be managed by the library, which is sensible enough, but it is being applied indiscriminately here. I request that JDK-8306745 be reopened as a valid use case, so long as the authenticator is indeed limited to supplying Proxy-Authorization.

REGRESSION : Last worked in version 11.0.22

STEPS TO FOLLOW TO REPRODUCE THE PROBLEM : (supplied already in JDK-8306745)

CUSTOMER SUBMITTED WORKAROUND : The suggested workaround

don't use any authenticator, and explicitly handle 401/407 in the calling code

does not seem satisfactory. First of all, this essentially means reimplementing the logic of communicating with a proxy, which is something the library is supposed to handle for you. Worse, the explicit 407 handling would need to be present in each user of the HttpClient. When the client builder is offered as a generic systemwide service to be used by a variety of code making distinct HTTP requests, this means it is impossible to configure an authenticated proxy systemwide and package that into a builder transparently, which seems to be the intent of the .proxy method.

The only other known workarounds are: stop using a proxy, or at least an authenticated one, if that is possible; switch to a third-party HTTP client (or perhaps the old java.net.HttpURLConnection); or go back to using Java 11 (since the new behavior cannot be disabled even on an emergency basis via jdk.httpclient.allowRestrictedHeaders).

FREQUENCY : always

New jcmd commands Thread.vthread_scheduler and Thread.vthread_pollers

Two commands have been added to the jcmd command line tool to print information that may be useful when diagnosing issues with virtual threads.

jcmd <pid> Thread.vthread_scheduler prints the virtual thread scheduler, the target parallelism, number of threads, and other useful counters. The output also includes the delayed task schedulers that support virtual threads doing timed operations.

jcmd <pid> Thread.vthread_pollers prints the I/O pollers that support virtual threads doing blocking network I/O operations.

jhsdb debugd is deprecated for removal

The debugd subcommand of the jhsdb tool is deprecated, for removal in a future release. jhsdb debugd is an RMI server which provides a remote interface for other jhsdb commands. Those commands use the --connect option which is therefore also deprecated for removal. This will not affect usage of jhsdb for debugging local VMs or core files.

jstatd is deprecated for removal

The jstatd tool is deprecated, for removal in a future release. jstatd is an RMI server application which monitors HotSpot VMs, and provides a remote interface for jstat. This will not affect usage of jstat for monitoring local VMs using the Attach API.

The 32-bit x86 Port has Been Deprecated for Removal

The 32-bit x86 port is deprecated in JDK 24, with the intent to remove it in a future release. This effectively deprecates support for 32-bit x86 on all operating systems. The architecture-agnostic Zero port would be the only remaining way to run Java programs on 32-bit x86 processors going forward. Systems that run on 32-bit x86 today, would need to either consider upgrading to 64-bit x86, or qualify 32-bit x86 Zero, or stay on previous JDKs.

Remove JDK1.1 compatible behavior for "EST", "MST", and "HST" time zones

The JDK1.1 compatible behavior for "EST", "MST", and "HST" time zones has been removed. The behavior was enabled by setting the sun.timezone.ids.oldmapping system property, which is a no-op in this release.

Support for CLDR Version 46

The locale data based on the Unicode Consortium's CLDR has been upgraded to version 46. Besides the usual addition of new locale data and translation changes, there are notable changes from the upstream CLDR, affecting Date/Time/Number formattings:

• First day of week is Monday in UAE CLDR-15697
• Default numbering system for Arabic in non-Arabic-speaking locations CLDR-17553
• Comma is added for some date formatting patterns CLDR-17812 -
• Some time zone names changed due to them becoming links to other zones CLDR-17960

Note that locale data is subject to change in a future release of the CLDR. Although not all locale data changes affect the JDK, users should not assume stability across releases. For more details, please refer to the Unicode Consortium's CLDR release notes and their locale data deltas.

New method Process.waitFor(Duration)

A new overloaded method java.lang.Process#waitFor(Duration) has been added. Existing waitFor() method with timeout needs both a primitive time out value and its unit. The new method uses java.time.Duration so that the user will not be confused with the unit.

MethodTypeDesc.resolveConstantDesc Throws ClassNotFoundException instead of TypeNotPresentException

In previous releases, MethodTypeDesc.resolveConstantDesc threw an unchecked TypeNotPresentException instead of a checked ReflectiveOperationException when a component class was not found. This behavior is now corrected to throw a ClassNotFoundException, conforming to the specification.

Code that previously handled TypeNotPresentException in addition to ReflectiveOperationException can consolidate the exception handling into the existing ReflectiveOperationException handling.

Support for Unicode 16.0

This release upgrades the Unicode version to 16.0, which includes updated versions of the Unicode Character Database and Unicode Standard Annexes #9, #15, and #29: - The java.lang.Character class supports the Unicode Character Database, which adds 5,185 characters, for a total of 154,998 characters. The new additions include seven new scripts: - Garay is a modern-use script from West Africa. - Gurung Khema, Kirat Rai, Ol Onal and Sunuwar are four modern-use scripts from Northeast India and Nepal. - Todhri is an historic script used for Albanian. - Tulu-Tigalari is an historic script from Southwest India. - The java.text.Bidi and java.text.Normalizer classes support Unicode Standard Annexes, #9 and #15, respectively. - The java.util.regex package supports Extended Grapheme Clusters based on the Unicode Standard Annex #29.

For more details about Unicode 16.0, refer to the Unicode Consortium’s release note.

SunPKCS11 provider is enhanced to use CKM_AES_CTS mechanism if supported by native PKCS11 library

The SunPKCS11 provider has been enhanced to support the following AES CTS transformations for the Cipher service type:

• AES/CTS/NoPadding
• AES_128/CTS/NoPadding
• AES_192/CTS/NoPadding
• AES_256/CTS/NoPadding

The Addendum to NIST Special Publication 800-38A defines three variants of Ciphertext Stealing for CBC mode: CBC-CS1, CBC-CS2, and CBC-CS3. To ensure interoperability with SunJCE and Kerberos which use the CS3 variant, the SunPKCS11 provider needs to know the variant implemented by the underlying PKCS #11 library and convert the data if it is not in the CS3 variant. A new SunPKCS11 provider configuration attribute named cipherTextStealingVariant is introduced and must be set with any of the following values: CS1, CS2 or CS3 to indicate the CTS variant of the underlying PKCS #11 library, except for NSS as it is known to be CS1. Otherwise, the PKCS #11 CKM_AES_CTS mechanism is disabled.

Disable "best-fit" Mapping on Windows Command Line

Command line arguments to the Java launcher are no longer converted with Windows' "best-fit" mapping when the arguments include unmappable characters for the ANSI code page. This mapping has been intervening in the Java launcher's argument parsing. Unmappable characters are now replaced with the default replacement character, such as '?' in some cases. For rare cases, where applications need those unmappable characters on the command line, select UTF-8 in Windows Regional Settings.

The java Command Line Options `-t`, `-tm`, `-Xfuture`, `-checksource`, `-cs`, and `-noasyncgc` are Removed

The java command no longer accepts the -t, -tm, -Xfuture, -checksource, -cs, and -noasyncgc options.

These options are henceforth treated as unrecognized and usage of any of these options will lead to an error resulting in a failure to launch java. Applications that were launching java with the -Xfuture option may consider using -Xverify:all in its place - the rest of the options have no replacements.

Removal of serialVersionUID Compatibility Logic from JMX

Some javax.management classes contained a feature for Serialization compatibility with very old JMX releases (1.0, 1.1, 1.2), which are from before JMX was an integrated part of the JDK (in JDK 5). This was enabled using the jmx.serial.form system property.

This compatibility logic offered no value, and only added complexity, so has been removed. This will not affect any JMX features, or any interactions between JMX features in different JDKs.

The `LockingMode` Flag, Along With The `LM_LEGACY` And `LM_MONITOR` Modes Are Deprecated

A new lightweight locking mechanism for object monitor locking was introduced in JDK 21 under JDK-8291555. The LockingMode flag was introduced to allow selection of this new mechanism (LM_LIGHTWEIGHT, value 2) in place of the default mechanism (LM_LEGACY, value 1). In JDK 23, the LockingMode default was changed to LM_LIGHTWEIGHT.

In JDK 24, the LockingMode flag, along with the LM_LEGACY (1) and LM_MONITOR (0) modes are deprecated. The default locking mode LM_LIGHTWEIGHT will be the only internal implementation that is supported when these locking modes become obsolete in a future release.

This is not expected to change any semantic behavior of Java monitor locking and it is expected to be performance neutral for almost all applications.

RedefineClasses verifies the redefined classes

When redefining a class with JVMTI RedefineClasses, the new bytecodes are verified with the Class File Verifier regardless of the setting of the deprecated -Xverify option.

Decorate Newlines in Unified Logging Multiline Messages

Unified Logging now outputs a special empty decorator [ ] followed by a space after newlines in multiline log messages. This change allows unambiguous parsing of Unified Logging output.

To illustrate the change, consider the output of log_info(gc)("A\n[gc] B");: ` [gc] A [ ] [gc] B It is possible to parse this multiline message unambiguously. This was previously not possible, as the output was `` [gc] A [gc] B `` which could (and likely would be) parsed as two distinct log messagesAandB`.

Tools that currently deal with multiline parsing ambiguities in Unified Logging require an update. The updates will likely result in simpler and more robust implementations.

Compact Object Headers (Experimental)

This release adds the experimental support for compact object headers. In current 64-bit implementations, Java objects have 12-byte header. Compact object headers reduce header sizes to 8 bytes, improving Java heap footprint. This experimental feature can be enabled with -XX:+UnlockExperimentalVMOptions -XX:+UseCompactObjectHeaders. See more details in JEP 450.

Added SSL.com TLS Root CA Certificates Issued in 2022

The following root certificates have been added to the cacerts truststore: ``` + SSL.com + ssltlsrootecc2022 DN: CN=SSL.com TLS ECC Root CA 2022, O=SSL Corporation, C=US

• SSL.com
• ssltlsrootrsa2022 DN: CN=SSL.com TLS RSA Root CA 2022, O=SSL Corporation, C=US ```

Support for Including Security Properties Files

The java.security security properties file and those referred to by the java.security.properties system property now support including other properties files. The directive include <path-to-a-file> can be used for this purpose. The effect of including a file is equivalent to defining its properties inline at the inclusion point. See more information and examples in the Security Properties Files Inclusion section of the Security Developer Guide and in JDK-8319333.

As a result of this change, the name include can no longer be used to define a property in a security properties file. If the name include is passed to the java.security.Security::getProperty or ::setProperty APIs, an IllegalArgumentException is thrown.

SHA3 performance improved

The performance of the MessageDigest implementations that belong to the SHA3 family (SHA3-224, SHA3-256, SHA3-384 and SHA3-512) has been improved by 6-27 % (depending on digested message length and on the platform used), and an additional 30-40% on AVX-512 capable platforms due to new intrinsic implementations on that platform.

Updated HSS/LMS Public Key Encoding

The X.509 encoded format for HSS/LMS public keys has been updated to align with the latest standard outlined in RFC 9708. Notably, the additional OCTET STRING wrapping around the public key value has been removed. For compatibility, public key encodings generated by earlier JDK releases are still recognized.

Document Standard Hash and MGF Algorithms for RSASSA-PSS Signature

A new section for PSSParameterSpec algorithm names has been added to the Java Security Standard Algorithm Names specification. This section lists the standard hash and message generation function (MGF) algorithms that can be specified when initializing an RSASSA-PSS signature with a PSSParameterSpec object.

Jarsigner Should Print a Warning If an Entry is Removed

If an entry is removed from a signed JAR file, there is no mechanism to detect that it has been removed using the JarFile API, since the getJarEntry method returns null as if the entry had never existed. With this change, the jarsigner -verify command analyzes the signature files and if some sections do not have matching file entries, it prints out the following warning: "This JAR contains signed entries for files that do not exist". Users can further find out the names of these entries by adding the -verbose option to the command.

SunMSCAPI Provider Opens the Windows Local Computer Key Store in Read-Only Mode in Non-Elevated Processes

The Local Computer key store is accessed using the CERT_STORE_MAXIMUM_ALLOWED_FLAG. Since this store is typically managed by administrators for security reasons, processes are only given read-only access to specific private keys. By opening the store in read-only mode, non-elevated processes can now securely use these keys without requiring elevated permissions.

Support for Time Zone Database 2024b

IANA Time Zone Database has been upgraded to 2024b. This version mainly includes changes to improve historical data for Mexico, Mongolia, and Portugal. It also changes one timestamp abbreviation, for the time zone 'MET'. Also Asia/Choibalsan is now an alias for Asia/Ulaanbaatar.

The new tzdata changes also impact some legacy zone IDs. Mapping of EST/MST/HST in java.time.ZoneId.SHORT_IDS have changed from fixed offset zones to links to other existing time zones with 2024b. "EST" now links to "America/Panama", "HST" links to "Pacific/Honolulu" and "MST" links to "America/Phoenix". Parsing of the short zone names "EST", "MST", and "HST" is not affected by this change. Further details are available at JDK-8340138

Support for Time Zone Database 2024b

IANA Time Zone Database has been upgraded to 2024b. This version mainly includes changes to improve historical data for Mexico, Mongolia, and Portugal. It also changes one timestamp abbreviation, for the time zone 'MET'. Also Asia/Choibalsan is now an alias for Asia/Ulaanbaatar.

The new tzdata changes also impact some legacy time zone IDs. As per 2024b changes "EST" links to "America/Panama", "HST" links to "Pacific/Honolulu" and "MST" links to "America/Phoenix". To maintain compatibility with the Java SE specification, the java.time.ZoneId.SHORT_IDS Map has not changed. Further details are available at JDK-8342331

Adjust JAXP limits

The JDK's XML Processing Limits (known as JAXP Limits) are adjusted to be more in line with general applications. In particular, the default values of the limits are tuned down to more closely align with known DTDs.

If an application processes XML documents that reference an extremely large DTD, it may encounter a parsing error such as the follows:

JAXP00010001: The parser has encountered more than "2500" entity expansions in this document; 
this is the limit imposed by the JDK.

To resolve the issue, application may increase the limit via the JAXP API. Using DOM processor as an example, the following code increases the expansion limit to 5000:

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setAttribute("jdk.xml.entityExpansionLimit", 5000);

Or in the JAXP Configuration File. A template for creating Strict JAXP Configuration File, jaxp-strict.properties.template, was provided in JDK 23 for developers to assess and prepare their applications for the changes.

To set the property in the configuration file, copy the template and create a custom configuration file:

cp $JAVA_HOME/conf/jaxp-strict.properties.template. /<my_path>/jaxp-strict.properties  

Edit and change the setting as follows:

jdk.xml.entityExpansionLimit=5000

As a system property, this property can also be set on the commandline, e.g.:

java -Djdk.xml.entityExpansionLimit=5000 myApp 

The Java tutorial, JAXP Processing Limits, provides a debug solution that can be used to analyze the usages and estimate the limits.

Adjust XSLT and XPath Extension Function Property

The default value of the property for XSLT and XPath Extension Functions, jdk.xml.enableExtensionFunctions, has been changed from true to false, which disables Extension Functions.

If an application handles XML transformation with a stylesheet that uses Extension Functions, it may encounter processing error such as the follows:

Use of the extension function '[function name]' is not allowed when extension functions are disabled
by the secure processing feature or the property 'jdk.xml.enableExtensionFunctions'. To enable extension
functions, set 'jdk.xml.enableExtensionFunctions' to 'true'.

For applications that require extension functions, the solution is to set the property jdk.xml.enableExtensionFunctions to true. This can be done via the Transform API, e.g.

        transformerFactory = TransformerFactory.newInstance();
        transformerFactory.setFeature("jdk.xml.enableExtensionFunctions", true);

Or in the JAXP Configuration File. A template for creating Strict JAXP Configuration File, jaxp-strict.properties.template, was provided in JDK 23 for developers to assess and prepare for this type of changes. To set the property, copy the template and create a custom configuration file:

cp $JAVA_HOME/conf/jaxp-strict.properties.template /<my_path>/jaxp-strict.properties

Edit and change the setting as follows:

jdk.xml.enableExtensionFunctions=true

Furthermore, as a system property, the property can also be set on the commandline, e.g.:

java -Djdk.xml.enableExtensionFunctions=true myApp` 

New Option to Extract a JAR File to a Specific Directory Using the jar Tool

The jar tool's extract operation has been enhanced to allow the --dir or the -C options to be used to specify the directory where the archive will be extracted.

Example Usages:

jar -xf foo.jar -C /tmp/bar/

or

jar --extract --file foo.jar --dir /tmp/bar/

Either of these commands will extract the foo.jar to the /tmp/bar directory.

Disable UDP When `udp_preference_limit` Is Set to 0

udp_preference_limit is a krb5.conf setting to control how a KDC-REQ message is sent. If the size of the message is greater than the value of udp_preference_limit, TCP will be used; otherwise UDP will be used. Before this change, setting it to zero is ignored and the message is sent with UDP. With this change, setting it to zero forces the message to be sent with TCP. This behavior is consistent with other Kerberos 5 vendors.

jrunscript Tool Is Deprecated for Removal

jrunscript tool has been deprecated and will be removed in a future release. Usage of this tool will now print a deprecation warning.

Reflective Invocation of VarHandle Signature Polymoprhic Methods Throws UnsupportedOperationException

Reflectively invoking VarHandle signature polymorphic methods is specified to throw UnsupportedOperationException. However, the implementation previously threw UnsatisfiedLinkError in such case. The behavior was adjusted to conform to the specification.

jpackage supports WiX Toolset v4 and v5 on Windows

jpackage can use WiX Toolset v4 and v5 in addition to v3 on Windows. It will automatically choose the newest installed version.

jpackage supports custom WiX sources in both WiX v3 and v4 formats.

If WiX Toolset v4 or v5 is used, jpackage will automatically convert custom WiX sources in WiX v3 format to WiX v4 format.

NumberFormat Supports IntegerOnly Parsing With Suffix

DecimalFormat, when the format expects a suffix, now parses correctly when the parse value contains a decimal symbol and isParseIntegerOnly() would return true. Previously, parsing would fail for such cases and the correct value never returned.

For example, in the following snippet, 5 will now be returned by the parse(String) invocation, instead of a ParseException thrown.

` NumberFormat fmt = NumberFormat.getPercentInstance(Locale.US); fmt.setParseIntegerOnly(true); fmt.parse("500.55%"); `

New jar command option to not overwrite existing files

The jar tool's extract operation has been enhanced to allow the --keep-old-files or the -k options to be used to preventing overwriting existing files.

Example Usages:

jar xkf foo.jar

or

jar --extract --keep-old-files --file foo.jar

Either of these commands will extract the foo.jar, and if an entry with the same name already exist in the target directory, then the existing file will not be overwritten.

java.util.zip.ZipError Is Deprecated for Removal

java.util.zip.ZipError has been deprecated for removal. This error class has been obsolete for many releases and has not been used by the reference implementation since Java 8.

Any existing code that used to throw java.util.zip.ZipError should consider throwing java.util.zip.ZipException instead. Code needing to catch this error when running on releases prior to Java 9 may be updated to catch the parent java.lang.InternalError class instead.

SHA3 performance improved

The performance of the MessageDigest implementations that belong to the SHA3 family (SHA3-224, SHA3-256, SHA3-384 and SHA3-512) has been improved by 6-27 % (depending on digested message length and on the platform used), and an additional 30-40% on AVX-512 capable platforms due to new intrinsic implementations on that platform.

Disabled TLS_RSA cipher suites

The TLSRSA cipher suites have been disabled by default, by adding "TLSRSA_" to the jdk.tls.disabledAlgorithms security property in the java.security configuration file. The TLSRSA cipher suites do not preserve forward-secrecy and are not commonly used. Some TLSRSA cipher suites are already disabled because they use DES, 3DES, RC4 or NULL, which are disabled. This action disables all remaining TLSRSA cipher suites. Any attempts to use cipher suites starting with "TLSRSA" will fail with an SSLHandshakeException. Users can, at their own risk, re-enable these cipher suites by removing "TLSRSA_" from the jdk.tls.disabledAlgorithms security property.

Distrust TLS Server Certificates Anchored by Entrust Root Certificates and Issued After Nov 11, 2024

The JDK will stop trusting TLS server certificates issued after November 11, 2024 and anchored by Entrust root certificates, in line with similar plans recently announced by Google and Mozilla. The list of affected certificates includes certificates branded as AffirmTrust, which are managed by Entrust.

TLS server certificates issued on or before November 11, 2024 will continue to be trusted until they expire. Certificates issued after that date, and anchored by any of the Certificate Authorities in the table below, will be rejected.

The restrictions will be enforced in the JDK implementation (the SunJSSE Provider) of the Java Secure Socket Extension (JSSE) API. A TLS session will not be negotiated if the server's certificate chain is anchored by any of the Certificate Authorities in the table below and the certificate has been issued after November 11, 2024.

An application will receive an Exception with a message indicating the trust anchor is not trusted, for example:

` TLS server certificate issued after 2024-11-11 and anchored by a distrusted legacy Entrust root CA: CN=Entrust.net Certification Authority (2048), OU=(c) 1999 Entrust.net Limited, OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.), O=Entrust.net `

If necessary, and at your own risk, you can work around the restrictions by removing "ENTRUST_TLS" from the jdk.security.caDistrustPolicies security property in the java.security configuration file.

The restrictions are imposed on the following Entrust Root certificates included in the JDK:

You can also use the keytool utility from the JDK to print out details of the certificate chain, as follows:

keytool -v -list -alias <your_server_alias> -keystore <your_keystore_filename>

If any of the certificates in the chain are issued by one of the root CAs in the table above are listed in the output you will need to update the certificate or contact the organization that manages the server.

Configurable New Session Tickets Count for TLSv1.3

A new system property, jdk.tls.server.newSessionTicket, sets the number of TLSv1.3 resumption tickets sent by a JSSE server per session. It can be set on the command line with -Djdk.tls.server.newSessionTicket=#, where # ranges from 0 to 10. The default is 1.

Distrust TLS Server Certificates Anchored by Entrust Root Certificates and Issued After Nov 11, 2024

The JDK will stop trusting TLS server certificates issued after November 11, 2024 and anchored by Entrust root certificates, in line with similar plans recently announced by Google and Mozilla. The list of affected certificates includes certificates branded as AffirmTrust, which are managed by Entrust.

TLS server certificates issued on or before November 11, 2024 will continue to be trusted until they expire. Certificates issued after that date, and anchored by any of the Certificate Authorities in the table below, will be rejected.

The restrictions will be enforced in the JDK implementation (the SunJSSE Provider) of the Java Secure Socket Extension (JSSE) API. A TLS session will not be negotiated if the server's certificate chain is anchored by any of the Certificate Authorities in the table below and the certificate has been issued after November 11, 2024.

An application will receive an Exception with a message indicating the trust anchor is not trusted, for example:

` TLS server certificate issued after 2024-11-11 and anchored by a distrusted legacy Entrust root CA: CN=Entrust.net Certification Authority (2048), OU=(c) 1999 Entrust.net Limited, OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.), O=Entrust.net `

If necessary, and at your own risk, you can work around the restrictions by removing "ENTRUST_TLS" from the jdk.security.caDistrustPolicies security property in the java.security configuration file.

The restrictions are imposed on the following Entrust Root certificates included in the JDK:

You can also use the keytool utility from the JDK to print out details of the certificate chain, as follows:

keytool -v -list -alias <your_server_alias> -keystore <your_keystore_filename>

If any of the certificates in the chain are issued by one of the root CAs in the table above are listed in the output you will need to update the certificate or contact the organization that manages the server.

SSLSessionContext clarification regarding timeout limit

The javadoc for SSLSessionContext has been reworded to make it clear that when the timeout limit is exceeded for a session, the object is marked so that future connections cannot resume or rejoin the session. Active sessions can continue to be used so long as resume and rejoin operations are not attempted.

Mechanism to disable TLS cipher suites by pattern matching

TLS cipher suites can be disabled with the jdk.tls.disabledAlgorithms security property in the java.security configuration file using one or more "" wildcard characters. For example, "TLSRSA" disables all cipher suites that start with "TLSRSA". Only cipher suites starting with "TLS_" are allowed to have wildcard characters.

Memory used by internal temporary direct buffers is no longer limited

The Java Virtual Machine (JVM) option MaxDirectMemorySize controls the maximum total size of memory that may be used for direct buffers in an instance of the JVM. Its default value is the maximum size of the heap. Prior to JDK 24, the amount of memory allocated for internal temporary direct buffers such as used, for example, when reading from or writing to a java.nio.channels.FileChannel, was included in this total. As of JDK 24, internal use of temporary direct buffers is no longer included in the total.

Linux desktop GTK2 support is removed

JDK's java.desktop module has internal code that interoperates with multiple versions of the GTK platform library. This is primarily to support the Swing GTK LookAndFeel.

The JDK previously included support for interoperating with the GTK 2 version of the library, which is reaching the end of its life. GTK 3 long ago superseded it and is supported by JDK as the preferred default, in which case to use GTK 2, apps must request it using the jdk.gtk.version System property. And since many recent distros make GTK 2 only an optional install, it may require extra work to use it, and future distros will likely not provide any way to install it.

Since all versions of Linux to be supported by JDK 24 provide GTK3, GTK2 support in JDK is now removed.

Setting the jdk.gtk.version System property to 2 or 2.2 will no longer have any effect, GTK 3 will be loaded.

New Summary Page for External Specifications

The API documentation contains a new summary page listing external specifications referenced by Java SE and JDK APIs. A link to the new summary page can be found in the Index page linked in the API documentation navigation bar.

`Reader.of(CharSequence)` Method

The static factory method java.io.Reader.of(CharSequence) has been added to get a Reader that reads characters from a CharSequence (String and StringBuilder are examples of a CharSequence). The returned Reader is more efficient than using a java.io.StringReader in some cases, as the latter requires conversion to String and synchronization.

jlink --add-modules ALL-MODULE-PATH requires explicit --module-path argument

Starting with JDK 24, jlink --add-modules ALL-MODULE-PATH option will require users to set the module path via --module-path option. Prior to JDK 24, --add-modules ALL-MODULE-PATH without --module-path can be used to create an image with all JDK modules from $JAVA_HOME/jmods. In JDK 24, to create an image using ALL-MODULE-PATH, it is required to explicitly set --module-path.
To create an image with all JDK modules, use jlink --add-modules ALL-MODULE-PATH --add-modules $JAVA_HOME/jmods instead.

The ClassLoadingMXBean and MemoryMXBean isVerbose Methods Are Now Consistent with Their setVerbose Methods

The ClassLoadingMXBean::setVerbose(boolean enabled) method will set class+load* logging on log output stdout to level info if enabled is true, and to level off otherwise. In contrast, the isVerbose method would check if exactly class+load logging was enabled at the info level on any log output. This could result in counter-intuitive behavior when logging class+load=info to a file via the command-line, as it caused isVerbose to return true, even after a call to setVerbose(false) had been made. A similar problem existed for the MemoryMXBean::isVerbose method. Starting with this release, the behavior is as follows:

• ClassLoadingMXBean::isVerbose will return true only if class+load* logging (note the wildcard use) has been enabled at the info level (or above) on the stdout log output.
• MemoryMXBean::isVerbose will return true only if gc logging has been enabled at the info level (or above) on the stdout log output.

New MXBean to monitor/manage virtual thread scheduler

A new JDK-specific monitoring and management interface jdk.management.VirtualThreadSchedulerMXBean has been added to allow Java Management Extension (JMX) based tooling monitor and manage the virtual thread scheduler. The interface supports monitoring the virtual thread scheduler's target parallelism, the threads used by the scheduler, and the number of virtual threads queued to the scheduler. It also supports dynamically changing the scheduler's target parallelism.