Key:

JDK-X  - https://bugs.openjdk.java.net/browse/JDK-X
CVE-XXXX-YYYY: https://cve.mitre.org/cgi-bin/cvename.cgi?name=XXXX-YYYY

New in release OpenJDK 20.0.0 (2023-03-21):
===========================================
Major changes are listed below.  Some changes may have been backported
to earlier releases following their first appearance in OpenJDK 20.

The full list of changes in 20u can be found at:
-  * https://builds.shipilev.net/backports-monitor/release-notes-20.txt

NEW FEATURES
============

Language Features
=================

Pattern Matching for switch
===========================
https://openjdk.org/jeps/406
https://openjdk.org/jeps/420
https://openjdk.org/jeps/427
https://openjdk.org/jeps/433

Enhance the Java programming language with pattern matching for
`switch` expressions and statements, along with extensions to the
language of patterns. 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.

This is a preview feature (http://openjdk.java.net/jeps/12) introduced
in OpenJDK 17 (JEP 406), which saw a second preview in OpenJDK 18 (JEP
420) and a third in OpenJDK 19 (JEP 427).  It reaches its fourth
preview (JEP 427) in OpenJDK 20.

Record Patterns
===============
https://openjdk.org/jeps/405
https://openjdk.org/jeps/432

Enhance 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.

This is a preview feature (http://openjdk.java.net/jeps/12) introduced
in OpenJDK 19 (JEP 405). It reaches its second preview (JEP 432) in
OpenJDK 20.

Library Features
================

Scoped Values
=============
https://openjdk.org/jeps/429

Introduce 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.

This is an incubation feature (https://openjdk.java.net/jeps/11)
introduced in OpenJDK 20 (JEP 429).

Vector API
==========
https://openjdk.org/jeps/338
https://openjdk.org/jeps/414
https://openjdk.org/jeps/417
https://openjdk.org/jeps/426
https://openjdk.org/jeps/438

Introduce an API to express vector computations that reliably compile
at runtime to optimal vector hardware instructions on supported CPU
architectures and thus achieve superior performance to equivalent
scalar computations.

This is an incubation feature (https://openjdk.java.net/jeps/11)
introduced in OpenJDK 16 (JEP 338). A second round of incubation took
place in OpenJDK 17 (JEP 414), OpenJDK 18 (JEP 417) saw a third,
OpenJDK 19 a fourth (JEP 426) and OpenJDK 20 (JEP 438) sees its fifth.

Foreign Function & Memory API
=============================
https://openjdk.org/jeps/412
https://openjdk.org/jeps/419
https://openjdk.org/jeps/424
https://openjdk.org/jeps/434

Introduce 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.

This API is now a preview feature (http://openjdk.java.net/jeps/12).
It was first introduced in incubation
(https://openjdk.java.net/jeps/11) in OpenJDK 17 (JEP 412), and is an
evolution of the Foreign Memory Access API (OpenJDK 14 through 16) and
Foreign Linker API (OpenJDK 16) (see release notes for
java-17-openjdk). OpenJDK 18 saw a second round of incubation (JEP
419) before its inclusion as a preview in OpenJDK 19 (JEP 424).  It
reaches a second preview in OpenJDK 20 (JEP 434).

Virtual Threads
===============
https://openjdk.org/jeps/425
https://openjdk.org/jeps/436

Introduce 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.

This is a preview feature (http://openjdk.java.net/jeps/12) introduced
in OpenJDK 19 (JEP 425) and reaching its second preview in OpenJDK 20
(JEP 436).

Structured Concurrency
======================
https://openjdk.org/jeps/428
https://openjdk.org/jeps/437

Simplify 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.

This is an incubation feature (https://openjdk.java.net/jeps/11)
introduced in OpenJDK 19 (JEP 428). A second round of incubation takes
place in OpenJDK 20 (JEP 437).