JDK 19: The features targeted for Java 19

Java Progress Package 19, owing this September, has just experienced a sixth characteristic proposed for it: a preview of history patterns, for facts navigation and processing. Report designs joins 5 prior options, ranging from a preview of a overseas purpose and memory API to assistance for the open up supply Linux/RISC-V instruction established architecture (ISA).

JDK 19, or simply just Java 19, perhaps could host a large amount of features, ranging from universal generics to price objects, in accordance to strategies underway for maximizing Java. JDK 19 would adhere to JDK 18, which arrived March 22. Common Java is on a six-month launch cadence.

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

Early entry builds of JDK 19 can be accessed from jdk.java.net/19. Proposed JDK 19 features contain:

• A preview of file styles, to deconstruct document values. Document designs and style patterns can be nested to allow a declarative, impressive, and composable form of details navigation and processing. Aims of the proposal include things like extending sample matching to convey much more advanced, composable details queries even though not switching the syntax or semantics of variety designs. This proposal builds on pattern matching for instanceof, delivered in JDK 16  in March 2021. Upcoming ideas could call for document styles to be extended with abilities this kind of as array styles and vararg designs. Record designs is aspect of Undertaking Amber, an energy to check out and incubate smaller sized, productiveness-oriented Java options.
• A preview of a foreign function and memory API, which would introduce an API by which Java programs can interoperate with code and info outside the house the Java runtime. By competently invoking overseas functions (i.e., code outdoors the Java runtime) and safely and securely accessing foreign memory (i.e., memory not managed by the JVM) the API enables Java programs to contact indigenous libraries and method native data without the need of the threat and brittleness of the Java Indigenous Interface (JNI). The foreign functionality and memory API combines two earlier incubating APIs: the international memory obtain API and the foreign linker API. The foreign purpose and memory API was beforehand incubated in JDK 17 and reincubated in JDK 18. The proposal’s ambitions include things like simplicity of use, effectiveness, generality, and safety.
• A preview of virtual threads, which are light-weight threads that significantly lower the energy of composing, retaining, and observing superior-throughput, concurrent purposes. Aims incorporate enabling server programs penned in the uncomplicated thread-for every-ask for design to scale with around-best components utilization, enabling current code that uses the java.lang Thread API to undertake virtual threads with minimal change, and empower troubleshooting, debugging, and profiling of virtual threads with present JDK tools. It is not a aim of this proposal to modify the basic concurrency design in Java or provide a new data parallelism build in either the Java language or Java libraries. Nor is it a goal to get rid of the regular implementation of threads or to silently migrate current programs to use virtual threads.
• A 3rd preview of pattern matching for swap expressions and statements, extending pattern matching to swap, to enable an expression to be examined towards a selection of designs, every single with a precise motion, so intricate knowledge-oriented queries can be expressed concisely and securely. This capacity formerly was previewed in JDK 17 and JDK 18. The third preview would insert refinements which includes the substitution of guarded designs with when clauses in change blocks. Also, the runtime semantics of a sample swap when the value of the selector expression is null are a lot more closely aligned with legacy swap semantics. The plan’s aims consist of expanding the expressiveness and applicability of change expressions and statements by making it possible for patterns to look in scenario labels. This will allow for developers to take it easy the historic null-hostility of switch when desired, and is supposed to boost the safety of switch statements and assure that existing switch expressions and statements continue on to compile with no changes and execute with equivalent semantics.
• A fourth incubation of a vector API that would categorical vector computations that reliably compile at runtime to exceptional vector guidance on supported CPU architectures, therefore obtaining functionality outstanding to equal scalar computations. Developers making use of the API gain a way to produce elaborate vector algorithms in Java, applying the HotSpot auto-vectorizer but with a consumer model that helps make vectorizations much more predictable and robust. The vector API formerly was incubated into JDK 16, JDK 17, and JDK 19.
  Advancements to the API proposed for JDK 19 include things like enhancements to load and retailer vectors to and from MemorySegments, as defined by the International Operate and Memory API preview. JDK 19 would also include two cross-lane vector operations, compress and increase, with each other with a complementary vector mask compress operation. The compress vector operation maps lanes of a resource vector, chosen by a mask, to a desired destination vector in lane order, when the expand procedure does the inverse. The compress operation is valuable in filtering question benefits.
  In a different addition to the vector API, bitwise integral lanewide functions would be expanded, which include functions these counting the selection of just one bits, reversing the get of bits, and compressing and increasing bits. Targets of the API included being clear and concise, system-agnostic, having reliable runtime and compilation efficiency on x64 and AArch64 architectures, and enabling “swish” degradation, for cases in which a vector computation are not able to be thoroughly expressed at runtime as a sequence of vector functions.
• With the Linux/RISC-V port, Java would attain aid for a components instruction set that is by now supported by a huge selection of language toolchains. RISC-V in fact is a family members of similar ISAs. The Linux/RISC-V port would only support the RV64GV configuration of RISC-V, a common objective 64-little bit ISA that features vector guidance. The builders of Java may well contemplate other RISC-V configurations in the long term.

The port would help the next HotSpot VM possibilities: the template interpreter, C1 (consumer) JIT compiler, C2 (server) JIT compiler, and all recent mainline rubbish collectors including ZGC and Shenandoah. The real porting is nearly entire the emphasis of the JDK Improvement Proposal (JEP) is integration of the port into the JDK mainline repository.

Like JDK 18, JDK 19 is thanks to be a limited-term launch, with only 6 months of major-stage, Leading assistance.

The previous launch, JDK 17, was a Prolonged Term Assistance (LTS) launch, with numerous decades of aid. It arrived September 14, 2021.