Let's take a closer look at some of the latest improvements in the new release of the programming language on its 27th anniversary
Java - one of the most influential programming languages, celebrates its 27th anniversary today. There are millions of developers around the world using Java to create everything from desktop programs to web apps. This makes its mastery a useful skill for everyone who wants to work in the technology field. In recent times every year, a new version of Java is released with new features and improvements. In this article, we will take a closer look at the latest version, Java 20, which was released in March 2023, and we'll explore its new advances.
There are seven key features that are officially noted in the Java 20 release - amongst them are the virtual threads, vector API proposal, structured concurrency, scoped values, foreign function and memory APIs, record patterns and pattern matching for commands and expressions.
1. Virtual Threads: They are a prerequisite for a structured concurrency. The virtual threads redefine the interaction between the Java runtime and the underlying operating system. Java 19 introduced virtual threads to the Java platform as a first preview. In Java 20, JEP 436 provides a second preview of virtual threads in the older JEP 425 to allow time for further feedback collection. If there is no more feedback the virtual threads will be a production-ready feature in the upcoming Java 21 release.
2. Vector API proposal: This new API proposal was added a few weeks before the official release of Java 20 as a re-incubation. The implementation includes a small number of bug fixes and performance improvements, including the ability to express vector computations that are compiled at runtime and act like optimal vector instructions on supported CPUs.
3. Structured concurrency: Presented in JDK 19 as an incubating API, the structured concurrency operates by treating many tasks running in different threads as one work unit. This helps streamline error handling and cancellation, thereby improving reliability and enhancing observability. The only change in its re-introduction is that StructuredTaskScope has been updated to support inheritance of values by created in a task scope.
4. Scoped values: They enable immutable data to be shared across and within threads. Also, scoped values are preferred over the thread-local variables, especially when they are used with a large number of virtual threads. The goals of this incubating API are to achieve ease of use, comprehensibility, robustness, and performance.
5. Foreign function and Memory API: The Foreign Function and Memory (FFM) API combines two earlier incubating APIs: the Foreign-Memory Access API and the Foreign Linker API. The FFM API was first incubated in JDK 17 before being re-incubated in JDK 18. It was then first previewed in JDK 19. In response to the feedback from users, JDK 20 re-previews the FFM API with various refinements and improvements, such as:
- MemorySegment and MemoryAddress abstractions are unified (memory addresses are now modeled by zero-length memory segments);
- The sealed MemoryLayout hierarchy is enhanced to facilitate usage with pattern matching in switch expressions and statements by JEP 433;
- MemorySession has been split into an arena scope and SegmentScope to facilitate sharing segments across maintenance boundaries.
6. Record patterns: The record patterns were proposed as a preview feature in Java 19’s JEP 405. They provide an elegant way to access the elements of a record after a type check. Here are the main changes since the first preview:
- Add support for an inference of type arguments for generic record patterns;
- Add support for record patterns to appear in the header of an enhanced statement;
- Remove support for named record patterns.
7. Pattern matching: The pattern matching was first introduced as a preview feature in JDK 17, followed by a second preview in JDK 18, and a third preview in JDK 19. In JDK 20, the fourth preview of this language feature is presented, allowing it to further evolve alongside the record patterns preview feature. This iteration includes essential updates to the grammar surrounding switch statements, ensuring seamless integration and compatibility between pattern matching and other language features.
It looks like Java 20 is bringing major improvements that are increasing the efficiency of the language. Are you passionate about Java and looking for new opportunities? Check out our vacancies and join us to explore together what Java would bring in the future.