Top Features Introduced in Java 21
Java 21, released in September 2023, brought several significant enhancements and new features to the platform. Here are some of the top features that developers should be aware of:
1. Virtual Threads (Second Preview)
Virtual Threads are lightweight threads that dramatically reduce the effort of writing, maintaining, and observing high-throughput concurrent applications. They are a key component of Project Loom. This is the second preview, refining the initial introduction.
Thread.startVirtualThread(() -> {
System.out.println("Running in a virtual thread!");
});
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
Future<String> userFuture = scope.fork(() -> fetchUser());
Future<Integer> orderFuture = scope.fork(() -> fetchOrder());
scope.join(); // Wait for both to complete, or one to fail
String user = userFuture.resultNow();
Integer order = orderFuture.resultNow();
System.out.println("User: " + user + ", Order ID: " + order);
}
Simplified concurrency with lightweight threads.
- Significantly reduces the overhead of creating and managing threads.
- Allows for writing concurrent code that looks more like traditional blocking code.
- Improves scalability and reduces resource consumption for I/O-bound tasks.
- The second preview introduces refinements and improvements based on feedback.
2. Scoped Values (Second Preview)
Scoped Values enable the sharing of immutable data across threads within a structured concurrency scope. They are preferred over thread-local variables, especially when using virtual threads, for their safety and efficiency.
import jdk.incubator.concurrent.ScopedValue;
ScopedValue<String> USER_ID = ScopedValue.newInstance();
void processRequest(String userId) {
ScopedValue.runWhere(USER_ID, userId, () -> {
handleInput();
validateInput();
// ... other operations that can access USER_ID.get()
});
}
void handleInput() {
System.out.println("Handling input for user: " + USER_ID.get());
}
Safe and efficient sharing of immutable data across threads.
- Provides a mechanism for sharing data that is limited in scope and immutable.
- More efficient and less error-prone than traditional thread-local variables, especially with virtual threads.
- Helps in maintaining data integrity in concurrent environments.
- The second preview includes refinements and clarifications.
3. Pattern Matching for switch (Third Preview)
Pattern Matching for switch expressions and statements allows for more expressive and safer conditional logic by matching against types and specific conditions within case labels. This is the third preview, indicating further stabilization.
String format(Object o) {
return switch (o) {
case Integer i -> String.format("int %d", i);
case String s -> String.format("String %s", s);
case Point p -> String.format("Point at (%d, %d)", p.x(), p.y());
case null -> "null";
default -> o.toString();
};
}
record Point(int x, int y) {}
More expressive and safer conditional logic.
- Allows matching on types and applying conditions directly within
caselabels. - Reduces boilerplate code and improves readability compared to chained
if-else instanceofchecks. - Ensures that all possible cases are handled, improving code safety.
- The third preview suggests this feature is nearing finalization.
4. Record Patterns (Second Preview)
Record Patterns enhance pattern matching to deconstruct record class instances. This makes it easier to extract components of records in a concise and readable way within instanceof checks and switch statements. This is the second preview.
record Point(int x, int y) {}
void printCoordinates(Object o) {
if (o instanceof Point(int x, int y)) {
System.out.println("x = " + x + ", y = " + y);
}
}
void processShape(Shape s) {
switch (s) {
case Circle(Point center, int radius) ->
System.out.println("Circle at (" + center.x() + ", " + center.y() + ") with radius " + radius);
case Rectangle(Point p1, Point p2) ->
System.out.println("Rectangle from (" + p1.x() + ", " + p1.y() + ") to (" + p2.x() + ", " + p2.y() + ")");
default -> System.out.println("Unknown shape");
}
}
sealed interface Shape permits Circle, Rectangle {}
record Circle(Point center, int radius) implements Shape {}
record Rectangle(Point p1, Point p2) implements Shape {}
Concise deconstruction of record class instances.
- Allows direct extraction of record components within pattern matching constructs.
- Improves code readability and reduces the need for explicit getter calls.
- Works seamlessly with sealed classes and pattern matching for comprehensive data handling.
- The second preview indicates ongoing refinement.
5. Sequenced Collections
Sequenced Collections introduce new interfaces (SequencedCollection, SequencedSet, SequencedMap) to represent collections that have a defined encounter order. This provides a unified way to access the first and last elements and reverse the order of elements.
import java.util.*;
List<String> list = new ArrayList<>(List.of("a", "b", "c"));
System.out.println(list.getFirst()); // a
System.out.println(list.getLast()); // c
List<String> reversedList = list.reversed();
System.out.println(reversedList); // [c, b, a]
Set<String> linkedHashSet = new LinkedHashSet<>(Set.of("x", "y", "z"));
System.out.println(linkedHashSet.getFirst()); // x
System.out.println(linkedHashSet.getLast()); // z
Set<String> reversedSet = linkedHashSet.reversed();
System.out.println(reversedSet); // [z, y, x]
Unified way to handle ordered collections.
- Provides consistent methods for accessing the first and last elements of ordered collections.
- Introduces a
reversed()method to create a reversed view of the collection. - Enhances the API for working with collections that maintain insertion order or a specific ordering.
6. Foreign Function & Memory API (Third Preview)
The Foreign Function & Memory (FFM) API enables Java programs to interoperate with code and data outside of the Java runtime. This includes accessing native libraries and manipulating off-heap memory. This is the third preview, aiming for greater stability and usability.
// Example (simplified, API is complex)
// import java.lang.foreign.*;
// import java.lang.invoke.MethodHandle;
// try (Arena arena = Arena.open()) {
// // Lookup native function
// Linker linker = Linker.nativeLinker();
// MethodHandle strlen = linker.downcallHandle(
// SymbolLookup.loaderLookup().lookup("strlen").orElseThrow(),
// FunctionDescriptor.of(ValueLayout.JAVA_LONG, ValueLayout.ADDRESS)
// );
// // Allocate off-heap memory
// MemorySegment str = arena.allocateUtf8String("Hello from Java!");
// // Invoke native function
// long length = (long) strlen.invokeExact(str);
// System.out.println("Length of string in native memory: " + length);
// }
Improved interoperability with native code and off-heap memory.
- Provides a safer and more efficient way to interact with native libraries compared to JNI.
- Allows for direct manipulation of off-heap memory, potentially improving performance for certain tasks.
- The third preview indicates significant progress towards a stable API.
7. Unnamed Variables and Patterns (Second Preview)
Unnamed variables (using _) and unnamed patterns enhance code readability by indicating that a variable or a record component is not used. This can clarify the intent and reduce potential confusion.
void printFirstElement(List<String> list) {
if (!list.isEmpty()) {
String first = list.get(0);
System.out.println("First element: " + first);
}
}
void processPoint(Point p) {
if (p instanceof Point(int x, _)) { // We only care about the x-coordinate
System.out.println("x-coordinate: " + x);
}
}
void logMessage(String message, Throwable _) { // We don't need the throwable object
System.err.println("Error: " + message);
}
Improving code clarity by indicating unused elements.
- Improves code readability by explicitly marking variables or pattern components that are not used.
- Reduces potential warnings from compilers or linters about unused variables.
- Makes the code’s intent clearer.
- The second preview suggests further refinement of this feature.
These are just some of the key features introduced in Java 21. The release also includes other improvements, performance enhancements, and updates to existing APIs. For a comprehensive list, refer to the official Java 21 release notes.
Leave a Reply