Work on features in the Java SE 21 Reference Implementation is
organized in terms of JDK Enhancement Proposals (JEPs).
Each feature
description gives a link to the corresponding JEP document as a
convenience, but that document is not a normative part of this
Specification. Some features are included in the Java SE 21 Reference
Implementation on a preview basis, to gain
exposure before achieving permanent status in a later release of the
Java SE Platform.
Summary
Libraries
Foreign Function & Memory API (Third Preview)
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 is a preview API.
Scoped Values (Preview)
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 a preview API.
Sequenced Collections
Introduce new interfaces to represent collections with a defined
encounter order. Each such collection has a well-defined first element,
second element, and so forth, up to the last element. It also provides
uniform APIs for accessing its first and last elements, and for
processing its elements in reverse order.
"Life can only be understood backwards; but it must be lived forwards."
— Kierkegaard
Structured Concurrency (Preview)
Simplify concurrent programming by introducing an API for structured concurrency. Structured concurrency treats groups of related tasks running in different threads as a single unit of work, thereby streamlining error handling and cancellation, improving reliability, and enhancing observability. This is a preview API.
Virtual Threads
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.
Security
Key Encapsulation Mechanism API
Introduce an API for key encapsulation mechanisms (KEMs), an encryption
technique for securing symmetric keys using public key cryptography.
Language
Pattern Matching for switch
Enhance 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.
Record Patterns
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.
String Templates (Preview)
Enhance the Java programming language with string templates. String templates complement Java's existing string literals and text blocks by coupling literal text with embedded expressions and template processors to produce specialized results. This is a preview language feature and API.
Unnamed Classes and Instance Main Methods (Preview)
Evolve the Java language so that students can write their first programs without needing to understand language features designed for large programs. Far from using a separate dialect of Java, students can write streamlined declarations for single-class programs and then seamlessly expand their programs to use more advanced features as their skills grow. This is a preview language feature.
Unnamed Patterns and Variables (Preview)
Enhance the Java language with unnamed patterns, which match a record component without stating the component's name or type, and unnamed variables, which can be initialized but not used. Both are denoted by an underscore character, _. This is a preview language feature.
Virtual Machine
Prepare to Disallow the Dynamic Loading of Agents
Issue warnings when agents are loaded dynamically into a running JVM. These warnings aim to prepare users for a future release which disallows the dynamic loading of agents by default in order to improve integrity by default. Serviceability tools that load agents at startup will not cause warnings to be issued in any release.
Preview features
A preview feature is a new feature of the Java language, Java Virtual
Machine, or Java SE API that is fully specified, fully implemented, and
yet impermanent.
Preview features must possess
the following properties:
- High quality. A preview feature must display the same level
of technical excellence and finesse as a final and permanent feature of
the Java SE Platform.
- Not experimental. A preview feature must not be
experimental, risky, incomplete, or unstable. An experimental feature
must not be previewed in a release of the Java SE Platform.
- Universally available. All preview features included in a
Java SE Platform Specification must be supported in full by every
implementation of that Specification.
Preview features may be removed in a future release, or upgraded to
permanent features of the Java SE Platform.
The Java SE API consists solely of Java APIs, but the complete
Java SE Platform includes non-Java APIs, such as JNI and JVM TI, and
language-independent protocols, such as
JDWP and
Java Object Serialization.
A preview feature may include changes to non-Java APIs and
language-independent protocols.
Implementations of this Specification must:
- support all, and only, the preview features included by this
Specification.
- disable all preview features in the Java language, Java Virtual
Machine, and Java SE API at compile time and run time by default.
- allow the user to indicate to the Java compiler and the Java
runtime that the entire set of preview features are to be enabled.
- not allow the user to enable preview features on an individual
basis, because they have equal status in the Platform and must be
enabled or disabled as a set.
- always enable the non-Java APIs and language-independent protocols
that are part of any preview feature, regardless of whether preview
features are enabled or disabled.
Additional details about preview features, including a description of
a
preview feature’s life cycle and the
relationship of preview features in the Java language to preview features
in the Java SE API, are available in
JEP 12 Preview Features.
This section may be compared to
the corresponding section that appeared in Java SE 18.
Restricted methods
Various methods in the Java SE API allow Java code to interoperate with
resources outside the Java runtime in such a way that the runtime cannot
prove correct or safe use of the resources. These methods, which are
provided because of their high utility, are specified as having the
potential to crash the Java runtime or corrupt memory. They are known as
restricted methods.
All methods in the Java SE API that are not restricted are
unrestricted. Given the potential danger of restricted methods,
developers should use restricted methods only when no suitable
functionality is available in unrestricted methods. To encourage
developers to seek unrestricted alternatives to restricted methods, the
following rule applies:
- An Implementation must issue a warning on the standard error
stream
every time a restricted method is invoked, unless (1) the
invocation
occurs in a class in the java.base module, or (2) the
invocation occurs in a class in a module identified previously to
ModuleLayer.Controller.enableNativeAccess, or (3) as
provided for
below.
An Implementation may provide a means to invoke its run-time system
with all restricted methods treated as unrestricted when invoked from
code identified to the run-time system.
If the run-time system is invoked in this way, then by definition
there are no restricted methods for the identified code to invoke, so no
warnings are issued during the execution of such code.
If code other than that identified to the run-time system invokes a
restricted method, the Implementation may give a signal other than a
warning issued on the standard error stream.
(The Reference Implementation provides the ability to treat
restricted methods as unrestricted for code in certain modules via
the command-line option --enable-native-access=M.
M is a comma-separated list of modules whose code is
permitted to invoke restricted methods as if they were unrestricted, i.e.,
without warnings. The special operand
ALL-UNNAMED
indicates every unnamed module, which includes code on the class
path. When the --enable-native-access option is present, any
invocation of restricted methods from code outside the listed modules will
cause an IllegalCallerException to be thrown, rather than a
warning to be issued.)
The restricted methods in Java SE 21 are:
Preparing for removal of finalization
An Implementation must support the finalization of objects, as described in
The Java Language Specification, section 12.6. However,
the Java SE 18 Platform Specification
deprecates finalization, for removal. To aid preparations for
the removal of finalization, an Implementation may provide a means
to invoke its run-time system with finalization disabled. If
finalization is disabled, the effect is that the Java Virtual
Machine never invokes an object’s finalizer before the storage for
the object is reclaimed by the garbage collector. An
Implementation must not, by default, disable finalization.
(The Reference Implementation provides the ability to disable
finalization via the command-line option
--finalization=disabled.)
Future revisions of this Platform Specification are expected to
disable finalization by default and, eventually, to remove finalization
from the Java Language Specification.
