{"id":107370,"date":"2023-03-22T00:48:09","date_gmt":"2023-03-21T22:48:09","guid":{"rendered":"https:\/\/prohoster.info\/?p=107370"},"modified":"2023-03-22T11:10:35","modified_gmt":"2023-03-22T09:10:35","slug":"vypusk-java-se-20","status":"publish","type":"post","link":"https:\/\/prohoster.info\/en\/blog\/news\/vypusk-java-se-20","title":{"rendered":"Release of Java SE 20","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"
After six months of development, Oracle has released Java SE 20 (Java Platform, Standard Edition 20), with the reference implementation being the open project OpenJDK. Aside from the removal of some deprecated features in Java SE 20, backward compatibility with previous releases of the Java platform has been maintained \u2014 most previously written Java projects will run successfully on the new version without changes. Installable builds of Java SE 20 (JDK, JRE, and Server JRE) have been prepared for Linux (x86_64, AArch64), Windows (x86_64), and macOS (x86_64, AArch64). The reference implementation of Java 20, developed under the OpenJDK project, is fully open under the GPLv2 license with GNU ClassPath exceptions allowing dynamic linking with commercial products. <\/p>\n
Java SE 20 is classified as a regular support release, with updates to be issued until the next release. For long-term support (LTS), Java SE 17 should be used, with updates provided until 2029. It\u2019s worth noting that starting from Java 10, the project transitioned to a new development process featuring a shorter release cycle. New functionality is now developed in a continuously updated master branch, which incorporates ready changes and from which branches for stabilizing new releases are created every six months. <\/p>\n
Notable new features in Java 20 include: <\/p>\n
\n
Preliminary support for Scoped Values has been proposed, allowing immutable data to be shared across threads and enabling efficient data exchange between child threads (values are inherited). Scoped Values are being developed as a replacement for thread-local variables and are more efficient when using a very large number of virtual threads (thousands and millions of threads). The key difference between Scoped Values and thread-local variables is that the former are set once, cannot be changed afterward, and remain accessible only during the thread's execution. class Server { final static ScopedValue CURRENT_USER = new ScopedValue(); void serve(Request request, Response response) { var level = (request.isAuthorized() ? ADMIN : GUEST); var user = new User(level); ScopedValue.where(CURRENT_USER, user) .run(() -> Application.handle(request, response)); } } class DatabaseManager { DBConnection open() { var user = Server.CURRENT_USER.get(); if (!user.canOpen()) throw new InvalidUserException(); return new DBConnection(...); } }\n
The second preliminary implementation of record patterns has been added, extending the pattern matching capabilities introduced in Java 16 for parsing values of record-type classes. For example: record Point(int x, int y) {} static void printSum(Object obj) { if (obj instanceof Point p) { int x = p.x(); int y = p.y(); System.out.println(x + y); } }\n
A fourth preliminary implementation of pattern matching in «switch» expressions has been added, allowing for the use of flexible patterns in «case» labels that cover a range of values, rather than requiring cumbersome chains of «if\u2026else» statements. static String formatterPatternSwitch(Object obj) { return switch (obj) { case Integer i -> String.format(«int %d», i); case Long l -> String.format(«long %d», l); case Double d -> String.format(«double %f», d); case String s -> String.format(«String %s», s); default -> o.toString(); }; }\n
A second preliminary implementation of the FFM (Foreign Function & Memory) API has been added, allowing Java programs to interact with external code and data by calling functions from external libraries and accessing memory outside of the JVM.\n
The second preliminary implementation of virtual threads has been added, representing lightweight threads that significantly simplify the writing and maintenance of high-performance multithreaded applications.\n
The second version of the experimental API for structured concurrency has been added, simplifying the development of multithreaded applications by handling multiple tasks running in different threads as a single block.\n
The fifth preliminary implementation of the Vector API has been added, providing features for vector computations that are executed using vector instructions of x86_64 and AArch64 processors, allowing operations to be applied simultaneously to multiple values (SIMD). Unlike the autovectorization capabilities for scalar operations provided by the HotSpot JIT compiler, the new API allows for explicit control over vectorization for parallel data processing. <\/ul>\n