JDK-27: hard sell?

The JDK release train is so stable that many do not pay attention anymore! Nonetheless, the new JDK-27 release is there and quite a few things to unpack.

• JEP 527: Post-Quantum Hybrid Key Exchange for TLS 1.3: enhances the security of Java applications that require secure network communication by implementing hybrid key exchange algorithms for TLS 1.3. Such algorithms defend against future quantum computing attacks by combining a quantum-resistant algorithm with a traditional algorithm. Applications that use the javax.net.ssl APIs will benefit from these improved algorithms by default, without change to existing code.

• JEP 523: Make G1 the Default Garbage Collector in All Environments: makes the Garbage-First (G1) garbage collector the default collector in all environments, rather than just server environments. It worth noting that all other collectors are still available and could be specified, only default changes.

• JEP 534: Compact Object Headers by Default: makes compact object headers the default object header layout in the HotSpot JVM. Compact object headers reduce object headers from 96 bits down to 64 bits on 64-bit architectures, thereby reducing heap size, improving deployment density, and increasing data locality.

• JEP 536: JFR In-Process Data Redaction: enhances JDK Flight Recorder (JFR) to redact command-line arguments and the initial values of environment variables and system properties in recordings. Redact this data before it leaves the process, so that sensitive information does not leak.

  The new sub-options redact-key and redact-argument have been introduced, allowing to specify one or more filters that select the command-line arguments, environment variables, and system properties to be redacted.

    java -XX:FlightRecorderOptions:'redact-key=confidential,redact-argument=https://*:*@*' ...
    

Quite a few preview and incubating (vectors!) features have been carried over from the previous releases, notably:

• JEP 538: PEM Encodings of Cryptographic Objects (Third Preview): introduces an API for encoding objects that represent cryptographic keys, certificates, and certificate revocation lists into the widely-used Privacy-Enhanced Mail (PEM) transport format, and for decoding from that format back into objects. This is a preview API feature.

• JEP 532: Primitive Types in Patterns, instanceof, and switch (Fifth Preview): enhances pattern matching by allowing primitive types in all pattern contexts, and extend instanceof and switch to work with all primitive types. This is a preview language feature.

• JEP 531: Lazy Constants (Third Preview): introduces an API for lazy constants, which are objects that hold unmodifiable data. Lazy constants are treated as true constants by the JVM, enabling the same performance optimizations that are enabled by declaring a field final. Compared to final fields, however, lazy constants offer greater flexibility as to the timing of their initialization. This is a preview API feature.

• JEP 533: Structured Concurrency (Seventh Preview): simplifies concurrent programming by introducing an API for structured concurrency. Structured concurrency treats groups of related tasks running in different threads as single units of work, thereby streamlining error handling and cancellation, improving reliability, and enhancing observability. This is a preview API feature.

• JEP 537: Vector API (12th Incubator): introduces an API to express vector computations that reliably compile at run time to optimal vector instructions on supported CPUs, thus achieving performance superior to equivalent scalar computations. This is an incubating API feature.

The standard library (to my surprise at least) got only a handful of changes and bug fixes introduced, the most interesting ones are below.

• JDK-8371683: TYPE_USE Annotations on a var Lambda Parameter Are Rejected: following the specification change in Java 20 (JDK-8295807), the following code should be illegal, as TYPE_USE annotation should not be applicable to variable declaration that uses var (including lambda parameter declaration):

  @Retention(value=RUNTIME)
  @Target(value={TYPE_USE})
  @interface Anno {
  }
  
  ...
  
  Function<Integer, String> f = (@Anno var val) -> Integer.toHexString(val);
      

• JDK-8371656: HashMap.putAll() optimizations: some optimizations in the bulk insertion methods.

• JDK-8272758: Improve HttpServer to avoid partial file name matches while mapping request path to context path: the behavior of the JDK built-in com.sun.net.httpserver.HttpServer implementation, when matching an incoming request path to an HttpContext path, was switched from string prefix matching to path prefix matching.

• JDK-8210336: DateTimeFormatter predefined formatters should support short time zone offsets: predefined ISO-8601 formatters that accept zone offsets should support short zone offsets for parsing.

• JDK-8377013: TimeZone.getDefault() returns obsolete id on Windows (Asia/Calcutta): the default time zone returned by TimeZone.getDefault() on Windows now reflects the latest IANA TZ database IDs, aligning with current IANA definition

• JDK-8196182: ServiceLoader.iterator().hasNext()/.next() may throw a LinkageError: the ServiceLoader specifies its iterator methods to throw ServiceConfigurationError "if an error occurs locating, loading or instantiating a service provider".

• JDK-8385924: GZIPInputStream.read() behaves differently on some Java versions: a new system property jdk.util.gzip.tryReadAheadAfterTrailer is introduced to allow applications to control how the java.util.zip.GZIPInputStream behaves when reading the next member in a GZIP stream.

• JDK-8380452: ZipOutputStream::putNextEntry(ZipEntry) throws unspecified IllegalArgumentException for unmappable entry name: updates java.util.zip.ZipOutputStream::putNextEntry(ZipEntry e) to throw ZipException instead of unspecified IllegalArgumentException when an entry name or comment cannot be encoded.

• JDK-8376698: Add Spliterator tests for TreeMap sub-maps: for the subSet from a java.util.TreeSet or a java.util.TreeMap::keySet, if such a set is empty, its spliterator now properly throws NullPointerException for tryAdvance and forEachRemaining.

• JDK-8371748: Remove the (empty) ThreadPoolExecutor.finalize() method: the finalizer in ThreadPoolExecutor has been removed.

• The java.lang.foreign.SegmentAllocator interface was improved with one new method:

  • default MemorySegment allocateFrom(String str, Charset charset, int srcIndex, int numChars)

• The java.lang.Math got three new methods introduced:

  • public static double acosh(double x)
  • public static double asinh(double x)
  • public static double atanh(double x)

• The java.lang.StrictMath mirrored the change:

  • public static double acosh(double x)
  • public static double asinh(double x)
  • public static double atanh(double x)

• Surpring addition to java.lang.String class:

  • public int encodedLength(Charset cs)

• One method was added to java.math.BigDecimal class:

  • public BigDecimal rootn(int n, MathContext mc)

• Quite useful improvements to java.time.format.DateTimeFormatterPatternProvider:

  • public abstract String getDateTimeFormatterPattern(FormatStyle dateStyle, FormatStyle timeStyle, String calType, Locale locale)
  • public abstract String getDateTimeFormatterPattern(String requestedTemplate, String calType, Locale locale)

That was it. Let us take a look which changes went into JVM itself, including garbage collection:

• JDK-8374348: -XX:AOTMode=required as alias for -XX:AOTMode=on: adds -XX:AOTMode=required as an alias to -XX:AOTMode=on (the intent is to deprecate and eventually remove -XX:AOTMode=on).

• JDK-8359706: VM.info and hs_err_pid Logs Now Report Current Open File Descriptor: adds printing of the current open file descriptor count to the VM.info output and hs_err_pid crash logs using native OS calls.

• JDK-8382582: Remove the experimental JVMCI feature: removes JVMCI Compiler Interface. This is pretty disruptive change, using the Graal compiler instead of C2 is not supported anymore.

• JDK-8227106: Rename -XX:InitiatingHeapOccupancyPercent to -XX:G1IHOP: only the G1 garbage collector uses the option -XX:InitiatingHeapOccupancyPercent but it is always available. As such, it was changed to -XX:G1IHOP for consistency and made available only if the G1 collector is available.

• JDK-8363996: The UseCompressedClassPointers Option Is Now Obsolete: UseCompressedClassPointers was deprecated in JDK-25, made obsolete, and its maintaining code was removed as well.

• JDK-8373481: Removal of -noclassgc, -noverify, -verifyremote and -Xverify:none Options: the -noclassgc, -noverify, -verifyremote and -Xverify:none were deprecated in JDK-24 for removal and now are removed.

• JDK-8238686: G1 may waste lots of space or fail to uncommit when observing MinHeapFreeRatio during sizing after full gc: changes the default values for MinHeapFreeRatio and MaxHeapFreeRatio flags when using the G1 garbage collector. Their new values will not affect Java heap sizing any more unless explicitly set by the user.

• JDK-8380590: Parallel: Improve tenuring-threshold heuristics: tries to make the heuristic bidirectional and based on observed young-gen signals. It should lower the threshold when survivor pressure squeezes eden, and raise it only after a short recovery window when young-gen commit headroom is available.

• JDK-8378331: G1: WeakProcessor IsAlive and KeepAlive closures not handling humongous candidates correctly: these closures now handle humongous candidates properly to allow eager reclaim.

• JDK-8373894: G1: Count evacuation-failed garbage collections in gc cpu usage: fixes one of the causes of the significant distortions in GC behavior.

• JDK-8377561: Parallel: Large allocations cause Full GC storm without heap expansion

• JDK-8381834: Improve TLAB sizing heuristics

Moving on to JDK and tooling, a number of highlights here:

• JDK-8296183: jndiprovider.properties contains properties pointing to non-existing classes: the jndiprovider.properties file was removed from the java.naming module.

• JDK-8371842: Support for CLDR Version 48.2: upgrades the CLDR data in the JDK to version 48.2.

• JDK-8381002: Thread dump should convert longs to json numbers if possible: changed the JSON format thread dump generated by HotSpotDiagnosticMXBean::dumpThreads API and the jcmd Thread.dump_to_file to convert Java longs to JSON numbers instead of strings.

• JDK-8378110: Add -XX: prefix to settings-file flags in RuntimeMXBean.getInputArguments(): the RuntimeMXBean::getInputArguments() method now adds the -XX prefix for arguments passed through a settings file.

• JDK-8377004: Java Launcher incorrectly allows inheriting a package-private main from another package: the proper inheritance rules will be followed when detecting the main methods to invoke.

• JDK-8355522: Remove the `java.locale.useOldISOCodes` system property: the property was introduced for the backward compatibility in JDK-17, deprecated in JDK-25 and now removed.

• JDK-8381511: Remove Obsolete Translation Resources: removes the majority of obsolete translation resource files from the JDK.

• JDK-8369227: Virtual thread stuck in PARKED state

• JDK-8379284: Avoid the need to keep obsolete preview feature constants until bootstrap JDK is upgraded

• JDK-8357439: Added Bash Autocompletion Script for the jcmd Tool: a Bash autocompletion script for the jcmd diagnostic tool has been added.

• JDK-8384164: JFR: Omit command-line arguments for jdk.SystemProcess: to avoid leaking sensitive information from processes running on the same computer, the jdk.SystemProcess event no longer emits command-line arguments.

• JDK-8382740: JFR: Disable jdk.OldObjectSample event for generational ZGC: the JFR event jdk.OldObjectSample is disabled when using generational ZGC.

• JDK-8367584: Implement JEP 536: JFR In-Process Data Redaction: the JVM option -XX:FlightRecorderOptions has been extended with a `help` option that lists the available suboptions.

      java -XX:FlightRecorderOptions:help
      

The list of different security related fixes and enhancements is truly impressive:

• JDK-8372526: Added Support for ZLIB TLS Certificate Compression: implements certificate compression in TLS 1.3 using internally supported ZLIB compression algorithm (see RFC-8879 for more details).

• JDK-8364182: New jcmd Command VM.security_properties Displays Active Security Properties at Runtime:

    jcmd  VM.security_properties
    

• JDK-8347938: Added Support for the Latest ML-KEM and ML-DSA Private Key Encodings: the JDK now encodes ML-KEM and ML-DSA private keys in PKCS #8 format using the DER-encoded ASN.1 CHOICE formats defined in Section 6, "Private Key Format" of RFC-9935 and Section 6, "Private Key Format" of RFC-9881. Two new security properties, jdk.mlkem.pkcs8.encoding and jdk.mldsa.pkcs8.encoding, control the encoding used when generating new keys with a KeyPairGenerator or when translating keys with a KeyFactory.

• JDK-8368692: Restrict Password::readPassword from reading from System.in: introduced a new security property named jdk.security.password.allowSystemIn to control whether JVM can read password from the standard input stream.

• JDK-8374808: New KeyStore and KeyStoreSpi Methods to Retrieve Creation Date as an Instant: new methods have been added to the KeyStore and KeyStoreSpi classes that return the creation dates of alias entries as java.time.Instant values:

  • public Instant KeyStore::engineGetCreationInstant(String alias)
  • public Instant KeyStoreSpi::engineGetCreationInstant(String alias)

• JDK-8369917: Additional Parameter Sets for HSS/LMS: the HSS/LMS signature algorithm now supports the additional parameter sets defined in RFC-9858, in addition to those originally defined in RFC-8554.

• JDK-8378893: X25519 should utilize a larger limb size: the increased limb size will increase performance by reducing the amount of limb operations by ~half when using 51-bit limbs.

• JDK-8384353: SHA3 AVX2 and AVX512 intrinsics and improvements: SHA-3 intrinsics have been optimized in this release for x86_64 systems that support AVX-512. The ML-KEM and ML-DSA algorithms extensively use SHA-3.

• JDK-8377550: Need to keep leading zeros in TlsPremasterSecret of TLS1.3 DHKeyAgreement: TLS 1.3 key agreement has been changed to use the Generic key algorithm for Diffie-Hellman shared secrets instead of the TlsPremasterSecret algorithm.

• JDK-8373426: Removal of ffdhe6144 and ffdhe8192 from the Default List of TLS Named Groups: ffdhe6144 and ffdhe8192 are rarely used groups and don't need to be in the default list.

By and large, JDK-27 is not the release that brings a lot to the table. Still, for many the post-quantum cryptography could be the thing warranting the adoption. All eye towards JDK-28 now.

I 🇺🇦 stand 🇺🇦 with 🇺🇦 Ukraine.

JDK-20: the most boring JDK release yet?

Still hot off the press, JDK-20 is out! These are terrific news, but what about exciting new features? Although a number of JEPs made it into the release, all of them are either preview or incubation features:

• JEP-429: Scoped Values (Incubator): introduces scoped values, which enable the sharing of immutable data within and across threads. They are preferred to thread-local variables, especially when using large numbers of virtual threads.

• JEP-432: Record Patterns (Second Preview): enhances the Java programming language with record patterns to deconstruct record values. Record patterns and type patterns can be nested to enable a powerful, declarative, and composable form of data navigation and processing.

• JEP-433: Pattern Matching for switch (Fourth Preview): enhances the Java programming language with pattern matching for switch expressions and statements. Extending pattern matching to switch allows an expression to be tested against a number of patterns, each with a specific action, so that complex data-oriented queries can be expressed concisely and safely.

  If you keen to learn more, please check out Using Pattern Matching publication, a pretty comprehensive overview of this feature.

• JEP-434: Foreign Function & Memory API (Second Preview): introduces an API by which Java programs can interoperate with code and data outside of the Java runtime. By efficiently invoking foreign functions (i.e., code outside the JVM), and by safely accessing foreign memory (i.e., memory not managed by the JVM), the API enables Java programs to call native libraries and process native data without the brittleness and danger of JNI.

• JEP-436: Virtual Threads (Second Preview): introduces virtual threads to the Java Platform. Virtual threads are lightweight threads that dramatically reduce the effort of writing, maintaining, and observing high-throughput concurrent applications.

• JEP-437: Structured Concurrency (Second Incubator): simplifies multithreaded programming by introducing an API for structured concurrency. Structured concurrency treats multiple tasks running in different threads as a single unit of work, thereby streamlining error handling and cancellation, improving reliability, and enhancing observability.

• JEP-438: Vector API (Fifth Incubator): introduces 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.

The pessimists may say this is the most boring release of JDK yet, but the optimist would argue that this is the calm before the storm (yes, I am talking about the next LTS release later this year, JDK-21). Nonetheless, there are quite a few notable changes to look at.

• JDK-8283093: JMX connections should default to using an ObjectInputFilter: enables RMI object filtering for JMX by default, by giving a default value to the existing management.properties setting, com.sun.management.jmxremote.serial.filter.pattern. The intent is to limit possible misuse of a JMX connection.

• The ability to stop, suspend, or resume a thread with the corresponding Thread.stop(), Thread.suspend() or Thread.resume() methods have been eliminated. Those methods have been degraded to throw a java.lang.UnsupportedOperationException exception as per JDK-8249627: Degrade Thread.suspend and Thread.resume and JDK-8289610: Degrade Thread.stop.

• JDK-8293590: Some syntax checks performed by URL.openConnection() could be performed earlier, at URL construction: previously, some of the parsing and validation actions performed by the URLStreamHander implementations were delayed until URLStreamHandler::openConnection or URLConnection::connect calls. Starting from JDK-20, some of these checks are performed earlier, at construction time, when URLStreamHandler::parseURL is called. A new JDK system property jdk.net.url.delayParsing can be specified on the command line to revert to the previous behavior.

• JDK-8292698: Improve performance of DataInputStream

• JDK-8297609: Add application/wasm MIME type for wasm file extension: adds application/wasm as a MIME type for WebAssembly mapping in the default shipped with the JDK content-types.properties file (for the reference, please check https://www.iana.org/assignments/media-types/application/wasm).

• JDK-8295803: Console should be usable in jshell and other environments

• JDK-8301863: ObjectInputFilter example incorrectly calls rejectUndecidedClass

• JDK-8254711: Add java.security.Provider.getService JFR Event: adds an event each time a JCE cryptographic service for a specific algorithm is requested and/or used.

• JDK-8291753: Add JFR event for GC CPU Time and JDK-8292373: Add JFR event for GC CPU Time (other GCs): adds a JFR event which includes same information through GCTraceCPUTime.

The standard library was the one benefited the most in JDK-20 release, let us take a closer look at what has changed:

• The java.io.BufferedInputStream got a specialized implementation for long transferTo(OutputStream out) throws IOException

• The java.io.PushbackInputStream got a specialized implementation for long transferTo(OutputStream out) throws IOException

• The java.io.SequenceInputStream got a specialized implementation for long transferTo(OutputStream out) throws IOException

• The java.lang.Float got two new conversion methods:

  • static float float16ToFloat(short floatBinary16)

  • static short floatToFloat16(float f)

• The java.lang.reflect package was enhanced with:

  • A new enum java.lang.reflect.AccessFlag

  • A new enum java.lang.reflect.ClassFileFormatVersion

  • The java.lang.reflect.Field got a new method:

    • Set<AccessFlag> accessFlags()

  • The java.lang.reflect.Member got a new method:

    • Set<AccessFlag> accessFlags()

  • The java.lang.reflect.Parameter got a new method:

    • Set<AccessFlag> accessFlags()

• The java.lang.Class class got a new method as well:

  • Set<AccessFlag> accessFlags()

• A new method was added to java.lang.module.ModuleDescriptor class:

  • Set<AccessFlag> accessFlags()

• The java.net.URL was enhanced with a factory method:

  • static URL of(URI uri, URLStreamHandler handler) throws MalformedURLException

• A new methods found their way into java.nio.file.spi.FileSystemProvider:

  • <A extends BasicFileAttributes> A readAttributesIfExists(Path path, Class<A> type, LinkOption... options)

  • boolean exists(Path path, LinkOption... options)

• As part of JDK-8297648: j.u.concurrent updates for JDK 20, couple of classes where enriched with new methods:

  • The java.util.concurrent.ForkJoinPool has gotten:

    • <T> ForkJoinTask<T> externalSubmit(ForkJoinTask<T> task)

  • The java.util.concurrent.ForkJoinWorkerThread has gotten:

    • int getQueuedTaskCount()

• A long standing bug JDK-8178355: IdentityHashMap uses identity-based comparison for values everywhere except remove(K,V) and replace(K,V,V) Export has been finally fixed by providing overrides in java.util.IdentityHashMap for:

  • boolean remove(Object key, Object value)

  • boolean replace(K key, V oldValue, V newValue)

• A couple of changes touched javax.net.ssl.SSLParameters class:

  • String[] getNamedGroups()

  • void setNamedGroups(String[] namedGroups)

• The improvements made inside java.util.regex package came as a pleasant surprise, those are related to named groups (JDK-8292872: MatchResult should provide values of named-capturing groups):

  • The java.util.regex.Matcher class got new methods:

    • boolean hasMatch()

    • Map<String, Integer> namedGroups()

  • The interface java.util.regex.MatchResult also got new methods:

    • default int end(String name)

    • default String group(String name)

    • default boolean hasMatch()

    • default Map<String, Integer> namedGroups()

    • default int start(String name)

• The java.util.zip.ZipInputStream introduces overrides for methods:

  • int read() throws IOException

  • byte[] readAllBytes() throws IOException

  • byte[] readNBytes(int len) throws IOException

  • int readNBytes(byte[] b, int off, int len) throws IOException

  • void skipNBytes(long n) throws IOException

  • long transferTo(OutputStream out) throws IOException

• A couple of new public constructors were introduced into the java.security.InvalidParameterException class:

  • InvalidParameterException(String msg, Throwable cause)
  • InvalidParameterException(Throwable cause)

The garbage collectors have got a considerable chunk of improvements (especially G1), covered by JDK 20 G1/Parallel/Serial GC changes in great details. To highlight just a few:

• JDK-8210708: Use single mark bitmap in G1: G1 native memory footprint has been reduced significantly by removing one of the mark bitmaps spanning the entire Java heap. Please check the brilliant Concurrent Marking in G1 article for deep technical dive.

• JDK-8292654: G1 remembered set memory footprint regression after JDK-8286115: fixes the previously introduced regression that caused significantly increased memory usage in some benchmarks.

• JDK-8256265: G1: Improve parallelism in regions that failed evacuation

• JDK-8137022: Concurrent refinement thread adjustment and (de-)activation suboptimal

• JDK-8297247: Add GarbageCollectorMXBean for Remark and Cleanup pause time in G1: adds Remark and Cleanup time to a G1 JMX bean.

From the security perspective, it worth mentioning these changes:

• JDK-8256660: Disable DTLS 1.0 by default: disables DTLS 1.0 by default by adding "DTLSv1.0" to the jdk.tls.disabledAlgorithms security property in the java.security configuration file.

• JDK-8290368: Introduce LDAP and RMI protocol-specific object factory filters to JNDI implementation: introduces LDAP-specific factories filter (defined by jdk.jndi.ldap.object.factoriesFilter property) and RMI-specific factories filter (defined by jdk.jndi.rmi.object.factoriesFilter property). The new factory filters are consulted in tandem with the jdk.jndi.object.factoriesFilter global factories filter to determine if a specific object factory is permitted to instantiate objects for the given protocol.

This releases proves one more time that boring is not always bad. If you want to learn more about these (and other) features in JDK-20, I would highly recommend going over Java 20 🥱 guide.

I 🇺🇦 stand 🇺🇦 with 🇺🇦 Ukraine.

JDK 19: revolution is looming!

The JDK-19 landed last month and may look like yet another routine release except it is not: Project Loom has finally delivered first bits! Alhough still in half-incubation / half-preview, it is a really big deal to the future of OpenJDK platform. Interestingly enough, a vast majority of the JDK-19 JEPs are either preview or incubating features. So, what JDK-19 has to offer?

• JEP-425: Virtual Threads (Preview): introduces virtual threads to the Java Platform. Virtual threads are lightweight threads that dramatically reduce the effort of writing, maintaining, and observing high-throughput concurrent applications.

• JEP-428: Structured Concurrency (Incubator): simplifies multithreaded programming by introducing an API for structured concurrency. Structured concurrency treats multiple tasks running in different threads as a single unit of work, thereby streamlining error handling and cancellation, improving reliability, and enhancing observability.

• JEP-405: Record Patterns (Preview): enhances the Java programming language with record patterns to deconstruct record values. Record patterns and type patterns can be nested to enable a powerful, declarative, and composable form of data navigation and processing.

• JEP-422: Linux/RISC-V Port: ports the JDK to RISC-V hardware.

• JEP-424: Foreign Function & Memory API (Preview): introduces an API by which Java programs can interoperate with code and data outside of the Java runtime. By efficiently invoking foreign functions (i.e., code outside the JVM), and by safely accessing foreign memory (i.e., memory not managed by the JVM), the API enables Java programs to call native libraries and process native data without the brittleness and danger of JNI. The JEP comes with a whole new java.lang.foreign package.

• JEP-426: Vector API (Fourth Incubator): introduces 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.

• JEP-427: Pattern Matching for switch (Third Preview): enhances the Java programming language with pattern matching for switch expressions and statements. Extending pattern matching to switch allows an expression to be tested against a number of patterns, each with a specific action, so that complex data-oriented queries can be expressed concisely and safely.

• JDK-8283620: New System Properties for `System.out` and `System.err`: two new system properties, stdout.encoding and stderr.encoding, have been introduced. The value of these system properties is the encoding used by the System.out and System.err streams respectively (the default values of these system properties depend on the platform and fallback to the native.encoding property when the console streams are not available).

• JDK-8212136: Remove finalizer implementation in SSLSocketImpl: the underlying native resource releases are now done by the Socket implementation (the TLS close_notify messages will no longer be emitted if SSLSocket is not explicitly closed).

• JDK-8255495: Support CDS Archived Heap for uncompressed oops: adds support for uncompressed oops for CDS archived heap (for now, only G1 GC is supported, ZGC as a future target).

• JDK-8261455: Automatically generate the CDS archive if necessary: allows the CDS archive to be automatically generated if necessary (e.g., if the specified archive doesn't exist, or if it's out of date because the JDK version was updated).

      java -XX:+AutoCreateSharedArchive -XX:SharedArchiveFile=app.jsa -cp app.jar AppMain
      

  In the previous JDKs, the CDS archive must be explicitly created before usage (with -Xshare:dump or -XX:ArchiveClassesAtExit).

• JDK-8278067: Make HttpURLConnection default keep alive timeout configurable: two new system properties have been added, http.keepAlive.time.server and http.keepAlive.time.proxy, which control the keep alive behavior of HttpURLConnection in the case where the server does not specify a keep alive time (by means of Keep-Alive header).

• JDK-8268081: Update Unicode Data Files to 14.0.0: introduces support of the Unicode Standard version 14.0.

• JDK-8281181: Do not use CPU Shares to compute active processor count: addresses an incorrect interpretation of the Linux cgroups parameter cpu.shares which might cause the JVM inside a container to use fewer CPUs than available.

• JDK-8274788: Support archived heap objects in ParallelGC: improves startup time since the module graph could be loaded from the archive.

• JDK-8280396: G1: Full gc mark stack draining should prefer to make work available to other threads and JDK-8280705: Parallel: Full gc mark stack draining should prefer to make work available to other threads: allow other threads to steal and distribute work.

• JDK-8176706: Additional Date-Time Formats: introduces additional date/time formats in the java.time.format.DateTimeFormatter and java.time.format.DateTimeFormatterBuilder classes. The new methods have been added to support that:

• To java.time.format.DateTimeFormatter:

  • static java.time.format.DateTimeFormatter ofLocalizedPattern(java.lang.String requestedTemplate)

• To java.time.format.DateTimeFormatterBuilder:

  • java.time.format.DateTimeFormatterBuilder appendLocalized(java.lang.String requestedTemplate)

  • static java.lang.String getLocalizedDateTimePattern(java.lang.String requestedTemplate, java.time.chrono.Chronology chrono, java.util.Locale locale)

• JDK-8285660: New System Property to Disable Windows Alternate Data Stream Support in java.io.File: a new system property jdk.io.File.enableADS has been added to control the access to NTFS Alternate Data Streams (ADS) on Windows (which is enabled by default).

• JDK-8280357: User's Home Directory set to $HOME if Invalid: on Linux and macOS, the system property user.home is set to the home directory provided by the operating system but if the directory name provided is empty or only a single character, the value of the environment variable HOME is going to be used instead.

• JDK-4511638: Double.toString(double) and Float.toString(float) may Return Slightly Different Results: the specification of these methods has been tightened comparing to earlier releases and the new JDK-19 implementation fully adheres to it. As a consequence, some returned strings are now shorter than when using earlier releases, and for inputs at the extremes of the subnormal ranges near zero, might look differently.

• JDK-8186958: New Methods to Create Preallocated HashMaps and HashSets: introduces new static factory methods to allow creation of HashMap and related instances that are preallocated to accommodate an expected number of mappings or elements.

  • Class java.util.WeakHashMap<K, V>

    • static <K, V> java.util.WeakHashMap<K, V> newWeakHashMap(int numElements)

  • Class java.util.HashMap<K, V>

    • static <K, V> java.util.HashMap<K, V> newHashMap(int numElements)

  • Class java.util.HashSet<E>

    • static <E> java.util.HashSet<E> newHashSet(int numElements)

  • Class java.util.LinkedHashMap<K, V>

    • static <K, V> java.util.LinkedHashMap<K, V> newLinkedHashMap(int numElements)

  • Class java.util.LinkedHashSet<E>

    • static <E> java.util.LinkedHashSet<E> newLinkedHashSet(int numElements)

• JDK-8274148: JShell Highlights Deprecated Elements, Variables, and Keywords: JShell now marks deprecated elements and highlights variables and keywords in the console.

• JDK-8271585: JFR: Scrub recording data: adds programmatic and command-line support to scrub a recording file (to scrub a recording file means to remove sensitive or uninteresting data to reduce the file size).

  jfr scrub [filters] [recording-file] [output-file]

  Please check out this short but insightful JFR Scrub - Sip of Java blog post to learn more about this JFR new command.

• From the standard library point of view, a large chunk of changes went into the classes under java.util.concurrent package so let us start from those:

• The java.util.concurrent.Future<T> (and its implementations like java.util.concurrent.CompletableFuture<T>, java.util.concurrent.FutureTask<T>, java.util.concurrent.ForkJoinTask<T>) got three new methods and one enumeration:

  • java.lang.Throwable exceptionNow()

  • T resultNow()

  • java.util.concurrent.Future$State state()

  • enum java.util.concurrent.Future$State

• The java.util.concurrent.ExecutorService now implements java.lang.AutoCloseable interface

• The java.util.concurrent.ForkJoinPool also implements java.lang.AutoCloseable interface and has two more methods:

  • <T> java.util.concurrent.ForkJoinTask<T> lazySubmit(java.util.concurrent.ForkJoinTask<T> task)

  • int setParallelism(int size)

• The java.util.concurrent.ForkJoinTask<T> additionally was enriched with:

  • static java.util.concurrent.ForkJoinTask<T> adaptInterruptible(java.util.concurrent.Callable<? extends T> callable)

  • boolean quietlyJoin(long timeout, java.util.concurrent.TimeUnit unit)

  • boolean quietlyJoinUninterruptibly(long timeout, java.util.concurrent.TimeUnit unit)

• The java.util.concurrent.Executors factory became even more capable with preview APIs:

  • static java.util.concurrent.ExecutorService newThreadPerTaskExecutor(java.util.concurrent.ThreadFactory threadFactory)

  • static java.util.concurrent.ExecutorService newVirtualThreadPerTaskExecutor()

• The java.lang.Thread comes at the end with whole bunch of additions (some also in preview):

  • boolean isVirtual()

  • boolean join(java.time.Duration duration)

  • long threadId()

  • static java.lang.Thread$Builder$OfPlatform ofPlatform()

  • static java.lang.Thread$Builder$OfVirtual ofVirtual()

  • static void sleep(java.time.Duration duration)

  • static java.lang.Thread startVirtualThread(java.lang.Runnable task)

  • interface Thread.Builder.OfVirtual

  • interface Thread.Builder.OfPlatform

  • interface Thread.Builder

• The java.lang.Long has introduced a new methods:

  • static long compress(long i, long mask)

  • static long expand(long i, long mask)

• Similarly, the java.lang.Integer has introduced this pair of methods:

  • static int compress(int i, int mask)

  • static int expand(int i, int mask)

• The class java.math.BigInteger got parallel multiplication support:

  • java.math.BigInteger parallelMultiply(java.math.BigInteger val)

• The class java.util.Locale was added a number of factory methods:

  • static java.util.Locale of(java.lang.String language, java.lang.String country, java.lang.String variant)

  • static java.util.Locale of(java.lang.String language, java.lang.String country)

  • static java.util.Locale of(java.lang.String language)

• The quite useful java.util.Objects utility class was not forgotten:

  • static java.lang.String toIdentityString(java.lang.Object o)

• The new factory method made it to java.util.Random class:

  • static java.util.Random from(java.util.random.RandomGenerator generator)

• The interface java.time.chrono.Chronology was enriched with new method:

  • boolean isIsoBased()

• Minor but useful addition to java.text.DecimalFormatSymbols class:

  • Locale getLocale()

• And java.lang.invoke.MethodHandles wraps it up with tons of new preview APIs:

  • static java.lang.invoke.VarHandle collectCoordinates(java.lang.invoke.VarHandle target, int pos, java.lang.invoke.MethodHandle filter)

  • static java.lang.invoke.VarHandle dropCoordinates(java.lang.invoke.VarHandle target, int pos, java.lang.Class<?>... valueTypes)

  • static java.lang.invoke.VarHandle filterCoordinates(java.lang.invoke.VarHandle target, int pos, java.lang.invoke.MethodHandle... filters)

  • static java.lang.invoke.VarHandle filterValue(java.lang.invoke.VarHandle target, java.lang.invoke.MethodHandle filterToTarget, java.lang.invoke.MethodHandle filterFromTarget)

  • static java.lang.invoke.VarHandle insertCoordinates(java.lang.invoke.VarHandle target, int pos, java.lang.Object... values)

  • static java.lang.invoke.VarHandle memorySegmentViewVarHandle(java.lang.foreign.ValueLayout layout)

  • static java.lang.invoke.VarHandle permuteCoordinates(java.lang.invoke.VarHandle target, java.util.List<Class<?>> newCoordinates, int... reorder)

From the security perspective, a few notable changes to mention (but feel free to go over much more detailed overview in the JDK 19 Security Enhancements post by Sean Mullan):

• JDK-8281561: Disable http DIGEST mechanism with MD5 and SHA-1 by default: the MD5 and SHA-1 message digest algorithms have been disabled by default for HTTP Digest authentication, they can re-enabled on an opt-in basis by setting a new system property http.auth.digest.reEnabledAlgorithms.

• JDK-8280494: (D)TLS signature schemes: introduces new APIs to customize the signature schemes for individual TLS or DTLS connections, for fine control of the security properties. The javax.net.ssl.SSLParameters was extended in these regards with two new methods:

  • java.lang.String[] getSignatureSchemes()

  • void setSignatureSchemes(java.lang.String[] signatureSchemes)

• JDK-8279842: HTTPS Channel Binding support for Java GSS/Kerberos: adds the support for TLS channel binding tokens for Negotiate/Kerberos authentication over HTTPS through HttpsURLConnection.

If you are one of the early adopters, please note that JDK-19 introduced a native memory usage regression very late in the release process so that the fix could not be integrated any more (JDK-8292654). The regression has already been addressed in JDK 19.0.1 and later.

With that, hope you are as excited as I am about JDK-19 release, the peaceful revolution is looming! And the JDK-20 early access builds are already there, looking very promising!

I 🇺🇦 stand 🇺🇦 with 🇺🇦 Ukraine.