JDK 19: The new features in Java 19

Java Improvement Kit 19, due this September, has just had a seventh characteristic proposed for it: structured concurrency, to simplify multithreaded programming. Structured concurrency joins six previous features which include report patterns, a preview of a foreign function and memory API, and assistance for the open up resource Linux/RISC-V instruction established architecture (ISA).

JDK 19, or simply Java 19, perhaps could host a large range of characteristics, ranging from universal generics to price objects, in accordance to ideas underway for boosting Java. JDK 19 would comply with JDK 18, which arrived March 22. Typical Java is on a 6-month launch cadence.

OpenJDK’s developers have posted an formal release program for JDK 19, which has it arriving September 20 as a creation launch, preceded by rampdown phases June 9 and July 21, and launch candidates to be revealed August 11 and August 25.

Early accessibility builds of JDK 19 can be accessed from jdk.java.internet/19. Proposed JDK 19 capabilities incorporate:

• Structured concurrency, in an incubator phase, is meant to simplify multithreaded programming by a structured concurrency library. This concurrency treats several jobs operating in various threads as a single unit of perform, to streamline error managing and cancellation. Reliability and observability are improved.
• A preview of file styles, to deconstruct report values. Report designs and type patterns can be nested to allow a declarative, potent, and composable form of details navigation and processing. Targets of the proposal include extending pattern matching to express far more innovative, composable knowledge queries though not transforming the syntax or semantics of form patterns. This proposal builds on pattern matching for instanceof, delivered in JDK 16  in March 2021. Foreseeable future ideas may well contact for record designs to be prolonged with capabilities this sort of as array designs and vararg styles. Report styles is element of Job Amber, an hard work to explore and incubate smaller, productiveness-oriented Java functions.
• A preview of a international perform and memory API, which would introduce an API by which Java plans can interoperate with code and data exterior the Java runtime. By efficiently invoking foreign functions (i.e., code exterior the Java runtime) and safely accessing overseas memory (i.e., memory not managed by the JVM) the API permits Java programs to contact indigenous libraries and course of action indigenous facts with no the risk and brittleness of the Java Native Interface (JNI). The foreign operate and memory API combines two previously incubating APIs: the international memory entry API and the international linker API. The international functionality and memory API was earlier incubated in JDK 17 and reincubated in JDK 18. The proposal’s targets include things like ease of use, functionality, generality, and safety.
• A preview of virtual threads, which are light-weight threads that significantly lower the work of writing, preserving, and observing substantial-throughput, concurrent purposes. Plans include things like enabling server applications penned in the simple thread-for every-ask for type to scale with close to-ideal hardware utilization, enabling present code that takes advantage of the java.lang Thread API to adopt virtual threads with minimum alter, and help troubleshooting, debugging, and profiling of virtual threads with current JDK applications. It is not a intention of this proposal to change the standard concurrency product in Java or offer a new information parallelism build in both the Java language or Java libraries. Nor is it a target to clear away the regular implementation of threads or to silently migrate current applications to use virtual threads.
• A third preview of sample matching for change expressions and statements, extending pattern matching to swap, to allow for an expression to be analyzed from a selection of designs, each and every with a specific motion, so advanced info-oriented queries can be expressed concisely and securely. This capability beforehand was previewed in JDK 17 and JDK 18. The 3rd preview would increase refinements like the substitute of guarded designs with when clauses in swap blocks. Also, the runtime semantics of a pattern change when the benefit of the selector expression is null are more intently aligned with legacy change semantics. The plan’s objectives include things like growing the expressiveness and applicability of swap expressions and statements by allowing patterns to seem in case labels. Other objectives consist of letting builders to take it easy the historic null-hostility of change when desired, escalating the safety of switch statements and guaranteeing that existing switch expressions and statements proceed to compile with no variations and execute with equivalent semantics.
• A fourth incubation of a vector API that would categorical vector computations that reliably compile at runtime to ideal vector instructions on supported CPU architectures, consequently reaching efficiency exceptional to equal scalar computations. Developers utilizing the API acquire a way to write elaborate vector algorithms in Java, using the HotSpot automobile-vectorizer but with a user model that would make vectorizations more predictable and robust. The vector API earlier was incubated into JDK 16, JDK 17, and JDK 19.
  Advancements to the API proposed for JDK 19 contain enhancements to load and keep vectors to and from MemorySegments, as outlined by the International Purpose and Memory API preview. JDK 19 would also insert two cross-lane vector functions, compress and extend, together with a complementary vector mask compress operation. The compress vector operation maps lanes of a supply vector, chosen by a mask, to a vacation spot vector in lane purchase, although the increase procedure does the inverse. The compress procedure is helpful in filtering question outcomes.
  In yet another addition to the vector API, bitwise integral lanewise functions would be expanded, together with operations these kinds of counting the amount of just one bits, reversing the purchase of bits, and compressing and expanding bits. Goals of the API integrated staying clear and concise, platform-agnostic, acquiring reliable runtime and compilation performance on x64 and AArch64 architectures, and enabling “swish” degradation, for circumstances in which a vector computation simply cannot be thoroughly expressed at runtime as a sequence of vector functions.
• With the Linux/RISC-V port, Java would get assist for a hardware instruction established that is now supported by a extensive range of language toolchains. RISC-V essentially is a spouse and children of connected ISAs. The Linux/RISC-V port would only guidance the RV64GV configuration of RISC-V, a normal intent 64-bit ISA that includes vector instructions. The builders of Java might take into account other RISC-V configurations in the foreseeable future.

The port would aid the subsequent HotSpot VM choices: the template interpreter, C1 (consumer) JIT compiler, C2 (server) JIT compiler, and all current mainline rubbish collectors which includes ZGC and Shenandoah. The precise porting is practically full the concentrate of the JDK Enhancement Proposal (JEP) is integration of the port into the JDK mainline repository.

Like JDK 18, JDK 19 is due to be a limited-expression release, with only 6 months of best-level, Leading assist.

The preceding release, JDK 17, was a Long Expression Support (LTS) release, with many yrs of guidance. It arrived September 14, 2021.