Java22 新特性

JDK 22 于 2024 年 3 月 19 日 发布

官方文档：OpenJDK Java 22 文档

Java各个版本的文档入口：Java平台，标准版文档

Java各个版本下载：https://jdk.java.net/archive/

JDK 22 共有 12 个新特性：

JEP 423: G1 的区域锚定

JEP 423: Region Pinning for G1

主要是通过引入Region Pinning来降低使用JNI时G1收集器的延时。与Java代码不同，JNI交互可能使用指向堆中对象的显式指针。当Java线程执行JNI 代码的关键区域时，无法在堆中重新定位这些对象。为了避免此问题，G1在关键区域禁用GC，这可能会导致延迟增加，因为如果其他非JNI线程触发GC，它们将被阻止。此更改允许G1 GC通过固定JNI代码使用的内存区域但允许重新定位和收集其他内存区域，即使线程位于关键区域也可以运行。

JEP 447: super(…) 前导语句（预览版）

JEP 447: Statements before super(…) (Preview)

作为一种面向对象的语言，Java 提供了扩展另一个（非最终）类并继承状态和行为（在允许的情况下）的能力。为了可靠地工作，必须以自上而下的顺序调用类的构造函数，以避免子类构造函数干扰超类构造函数。当开发人员决定显式调用超类构造函数时，这必须是第一个语句。这会带来一些限制，这可能会导致代码比预期的更复杂。其中最明显的是，在调用超类构造函数之前，无法对构造函数参数执行测试。如果测试导致引发异常，则对超类构造函数的调用在技术上将成为不必要的开销。

此JEP引入了一种在调用super之前允许语句的受控方法。

比如在JEP 447之前的代码如下：

public class PositiveBigInteger extends BigInteger {

    public PositiveBigInteger(long value) {
        super(value);               // Potentially unnecessary work
        if (value <= 0)
            throw new IllegalArgumentException(non-positive value);
    }

}

在JEP 447之后代码可以如下：

public class PositiveBigInteger extends BigInteger {

    public PositiveBigInteger(long value) {
        if (value <= 0)
            throw new IllegalArgumentException(non-positive value);
        super(value);
    }

}

JEP 454: 外部函数和内存 API

JEP 454: Foreign Function & Memory API

Foreign Function & Memory (FFM) API包含了两个incubating API
JDK14的JEP 370: Foreign-Memory Access API (Incubator)引入了Foreign-Memory Access API作为incubator
JDK15的JEP 383: Foreign-Memory Access API (Second Incubator)Foreign-Memory Access API作为第二轮incubator
JDK16的JEP 393: Foreign-Memory Access API (Third Incubator)作为第三轮，它引入了Foreign Linker API (JEP 389)
FFM API在JDK 17的JEP 412: Foreign Function & Memory API (Incubator)作为incubator引入
FFM API在JDK 18的JEP 419: Foreign Function & Memory API (Second Incubator)作为第二轮incubator
JDK19的JEP 424: Foreign Function & Memory API (Preview)则将FFM API作为preview API
JDK20的JEP 434: Foreign Function & Memory API (Second Preview)作为第二轮preview
JDK21的JEP 442: Foreign Function & Memory API (Third Preview)作为第三轮preview
JDK22的JEP 454则正式发布此特性

使用示例

// 1. Find foreign function on the C library path
Linker linker          = Linker.nativeLinker();
SymbolLookup stdlib    = linker.defaultLookup();
MethodHandle radixsort = linker.downcallHandle(stdlib.find("radixsort"), ...);
// 2. Allocate on-heap memory to store four strings
String[] javaStrings = { "mouse", "cat", "dog", "car" };
// 3. Use try-with-resources to manage the lifetime of off-heap memory
try (Arena offHeap = Arena.ofConfined()) {
    // 4. Allocate a region of off-heap memory to store four pointers
    MemorySegment pointers
        = offHeap.allocate(ValueLayout.ADDRESS, javaStrings.length);
    // 5. Copy the strings from on-heap to off-heap
    for (int i = 0; i < javaStrings.length; i++) {
        MemorySegment cString = offHeap.allocateFrom(javaStrings[i]);
        pointers.setAtIndex(ValueLayout.ADDRESS, i, cString);
    }
    // 6. Sort the off-heap data by calling the foreign function
    radixsort.invoke(pointers, javaStrings.length, MemorySegment.NULL, '\0');
    // 7. Copy the (reordered) strings from off-heap to on-heap
    for (int i = 0; i < javaStrings.length; i++) {
        MemorySegment cString = pointers.getAtIndex(ValueLayout.ADDRESS, i);
        javaStrings[i] = cString.reinterpret(...).getString(0);
    }
} 
// 8. All off-heap memory is deallocated here
assert Arrays.equals(javaStrings, new String[] {"car", "cat", "dog", "mouse"});  // true

JEP 456: 未命名变量和模式

JEP 456: Unnamed Variables & Patterns

Unnamed Patterns and Variables支持用_来替代没有使用的变量声明
JDK21的JEP 443: Unnamed Patterns and Variables (Preview)作为preview
JDK22的JEP 456则正式发布

比如之前的代码是这样子：

static boolean isDelayTimeEqualToReverbRoomSize(EffectLoop effectLoop) {
    if (effectLoop instanceof EffectLoop(Delay(int timeInMs), Reverb(String name, int roomSize))) {
        return timeInMs == roomSize;
    }
    return false;
}

使用此特性之后如下：

static boolean isDelayTimeEqualToReverbRoomSize(EffectLoop effectLoop) {
    if (effectLoop instanceof EffectLoop(Delay(int timeInMs), Reverb(_, int roomSize))) {
        return timeInMs == roomSize;
    }
    return false;
}

这里假设Reverb的name没有使用

其他示例1

int guitarCount = 0;
for (Guitar _ : guitars) {
    if (guitarCount < LIMIT) { 
        guitarCount++;
    }
}

其他示例2

var lesPaul = new Guitar("Les Paul");
try { 
    cart.add(stock.get(lesPaul, guitarCount));
} catch (OutOfStockException _) { 
    System.out.println("Sorry, out of stock!");
}

JEP 457: 类文件 API（预览版）

JEP 457: Class-File API (Preview)

JEP 457 提供了一个用于解析、生成和转换 Java 类文件的标准 API。此 API 处于预览状态。Java 生态系统有许多用于解析和生成 Java 类文件的库：ASM、BCEL、Javassist等大多数字节码生成框架都使用它们。Java类格式每6个月演化一次，每个新的Java版本都会发布，因此生成框架必须同时演进，否则可能会不支持最新的语言演进。JDK 本身使用ASM来实现它的一些工具，以及lambda实现，这在需要生成类文件的部分中，一个Java版本的功能与JVM中可以使用的功能之间存在差异，因为您必须等待支持版本 N 的新功能的 ASM 版本，然后才能在版本N+1中使用它们。类文件API通过在JDK中提供用于解析、生成和转换类文件的API来克服这个问题。

比如要生成如下方法

void fooBar(boolean z, int x) {
    if (z)
        foo(x);
    else
        bar(x);
}

用ASM的示例:

ClassWriter classWriter = ...;
MethodVisitor mv = classWriter.visitMethod(0, "fooBar", "(ZI)V", null, null);
mv.visitCode();
mv.visitVarInsn(ILOAD, 1);
Label label1 = new Label();
mv.visitJumpInsn(IFEQ, label1);
mv.visitVarInsn(ALOAD, 0);
mv.visitVarInsn(ILOAD, 2);
mv.visitMethodInsn(INVOKEVIRTUAL, "Foo", "foo", "(I)V", false);
Label label2 = new Label();
mv.visitJumpInsn(GOTO, label2);
mv.visitLabel(label1);
mv.visitVarInsn(ALOAD, 0);
mv.visitVarInsn(ILOAD, 2);
mv.visitMethodInsn(INVOKEVIRTUAL, "Foo", "bar", "(I)V", false);
mv.visitLabel(label2);
mv.visitInsn(RETURN);
mv.visitEnd();

使用此特性的示例:

ClassBuilder classBuilder = ...;
classBuilder.withMethod("fooBar", MethodTypeDesc.of(CD_void, CD_boolean, CD_int), flags,
                        methodBuilder -> methodBuilder.withCode(codeBuilder -> {
    Label label1 = codeBuilder.newLabel();
    Label label2 = codeBuilder.newLabel();
    codeBuilder.iload(1)
        .ifeq(label1)
        .aload(0)
        .iload(2)
        .invokevirtual(ClassDesc.of("Foo"), "foo", MethodTypeDesc.of(CD_void, CD_int))
        .goto_(label2)
        .labelBinding(label1)
        .aload(0)
        .iload(2)
        .invokevirtual(ClassDesc.of("Foo"), "bar", MethodTypeDesc.of(CD_void, CD_int))
        .labelBinding(label2);
        .return_();
});

JEP 458: 启动多文件源码程序

JEP 458: Launch Multi-File Source-Code Programs

JDK11的JEP 330: Launch Single-File Source-Code Programs引入了直接运行单个源文件的能力，一个缺点是所有源代码都必须放在一个文件中。要处理多个文件，仍然需要单独的编译步骤，这迫使开发人员在其项目中使用构建工具。如果开发人员仍然是初学者，那么情况可能会更糟：他们必须暂停对语言的学习，并且必须优先考虑学习或构建 Maven 或 Gradle 等工具。

Java22引入了一个启动器，它支持运行由多个文件组成的程序。假设一个目录包含两个文件Prog.java及Helper.java，其中每个文件声明一个类

// Prog.java
class Prog {
    public static void main(String[] args) { Helper.run(); }
}

// Helper.java
class Helper {
    static void run() { System.out.println("Hello!"); }
}

运行java Prog.java会在内存编译Prog并执行其main方法，这里Prog引用了Helper类，则启动器会在文件系统查找Helper.java文件然后内存编译。

如果是引用了jar包的类，则可以通过--class-path lib/*来指定，比如

Prog1.java
Prog2.java
Helper.java
libs/
├─ library1.jar
├─ library2.jar

可以通过如下来启动

$ java --class-path 'lib/*' Prog1.java
$ java --class-path 'lib/*' Prog2.java

如果libs里头的是模块化的，则可以使用如下方式启动

$ java -p lib Prog1.java
$ java -p lib Prog2.java

JEP 459: 字符串模板（第二轮预览）

JEP 459: String Templates (Second Preview)

JDK21的JEP 430: String Templates (Preview)引入了String Templates
JDK22作为第二次preview

使用示例

String title = "My Online Guitar Store";
String text = "Buy your next Les Paul here!";
String html = STR."""
        <html>
          <head>
            <title>\{title}</title>
          </head>
          <body>
            <p>\{text}</p>
          </body>
        </html>
        """;

JEP 460: 向量 API（第七轮孵化）

JEP 460: Vector API (Seventh Incubator)

JDK16引入了JEP 338: Vector API (Incubator)提供了jdk.incubator.vector来用于矢量计算
JDK17进行改进并作为第二轮的incubatorJEP 414: Vector API (Second Incubator)
JDK18的JEP 417: Vector API (Third Incubator)进行改进并作为第三轮的incubator
JDK19的JEP 426:Vector API (Fourth Incubator)作为第四轮的incubator
JDK20的JEP 438: Vector API (Fifth Incubator)作为第五轮的incubator
JDK21的JEP 448: Vector API (Sixth Incubator)作为第六轮的incubator
JDK22则作为第七轮的incubator，使用示例如下

void scalarComputation(float[] a, float[] b, float[] c) {
   for (int i = 0; i < a.length; i++) {
        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;
   }
}

static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;

void vectorComputation(float[] a, float[] b, float[] c) {
    int i = 0;
    int upperBound = SPECIES.loopBound(a.length);
    for (; i < upperBound; i += SPECIES.length()) {
        // FloatVector va, vb, vc;
        var va = FloatVector.fromArray(SPECIES, a, i);
        var vb = FloatVector.fromArray(SPECIES, b, i);
        var vc = va.mul(va)
                   .add(vb.mul(vb))
                   .neg();
        vc.intoArray(c, i);
    }
    for (; i < a.length; i++) {
        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;
    }
}

JEP 461: 流聚合器（预览版）

JEP 461: Stream Gatherers (Preview)

JDK22针对stream引入了gather操作，允许用户自定义中间操作，比如自定义distinctBy操作

guitars.stream()
        .gather(distinctBy(Guitar::guitarStyle))
        .forEach(System.out::println);

static <T, A> Gatherer<T, ?, T> distinctBy(Function<? super T, ? extends A> classifier) {
    Supplier<Map<A, List<T>>> initializer = HashMap::new;
    Gatherer.Integrator<Map<A, List<T>>, T, T> integrator = (state, element, _) -> {
        state.computeIfAbsent(classifier.apply(element), _ -> new ArrayList<>()).add(element);
        return true; // true, because more elements need to be consumed
    };
    BiConsumer<Map<A, List<T>>, Gatherer.Downstream<? super T>> finisher = (state, downstream) -> {
        state.forEach((_, value) -> downstream.push(value.getLast()));
    };
    return Gatherer.ofSequential(initializer, integrator, finisher);
}        

这里展示了使用gather的几个func：initializer(可选，用于维护状态)、integrator(用于集成输入)、combiner(可选，用于组合并行流)、finisher(可选，当stream没有输入的时候执行)

java.util.stream.Gatherers内置了如下几个操作：fold、mapConcurrent、scan、windowFixed、windowSliding

JEP 462: 结构化并发（第二轮预览）

JEP 462: Structured Concurrency (Second Preview)

JDK19的JEP 428: Structured Concurrency (Incubator)作为第一次incubator
JDK20的JEP 437: Structured Concurrency (Second Incubator)作为第二次incubator
JDK21的JEP 453: Structured Concurrency (Preview)作为首次preview
JDK22作为第二次preview，使用示例如下

Response handle() throws ExecutionException, InterruptedException {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
        Supplier<String>  user  = scope.fork(() -> findUser());
        Supplier<Integer> order = scope.fork(() -> fetchOrder());

        scope.join()            // Join both subtasks
             .throwIfFailed();  // ... and propagate errors

        // Here, both subtasks have succeeded, so compose their results
        return new Response(user.get(), order.get());
    }
}

JEP 463: 隐式声明类和实例主方法（第二轮预览）

JEP 463: Implicitly Declared Classes and Instance Main Methods (Second Preview)

JDK21的JEP 445: Unnamed Classes and Instance Main Methods (Preview)作为首次preview，引入了未命名的类和实例main方法特性可以简化hello world示例，方便java新手入门
JDK22作为第二次preview，它支持了更为灵活的程序启动协议，比如允许启动类的方法有public、protected权限，如果启动类包含参数方法则会选择有参数的，否则选择无参的main方法。

示例如下

        static void main(String[] args) {
            System.out.println("static main with args");
        }

        static void main() {
            System.out.println("static main without args");
        }

        void main(String[] args) {
            System.out.println("main with args");
        }

        void main() {
            System.out.println("main with without args");
        }

javac --release 21 --enable-preview Main.javajava --enable-preview Main
其中main方法选择的优先顺序是static的优于非static的，然后有args的优于没有args的

JEP 464: 作用域值（第二轮预览）

JEP 464: Scoped Values (Second Preview)

JDK20的JEP 429: Scoped Values (Incubator)作为Incubator
JDK21的JEP 446: Scoped Values (Preview)作为preview版本
JDK22作为第二次preview，具体使用如下：

class Server {
  public final static ScopedValue<User> LOGGED_IN_USER = ScopedValue.newInstance();
 
  private void serve(Request request) {
    // ...
    User loggedInUser = authenticateUser(request);
    ScopedValue.where(LOGGED_IN_USER, loggedInUser)
               .run(() -> restAdapter.processRequest(request));
    // ...
  }
}

通过ScopedValue.where可以绑定ScopedValue的值，然后在run方法里可以使用，方法执行完毕自行释放，可以被垃圾收集器回收

小结

这次更新的 12 项新特性里，有六个是归在核心 Java 库下面的：

• JEP 454：外部函数和内存 API，让你能更轻松地调用外部函数和管理内存；
• JEP 457：类文件 API（预览版），让你能更方便地处理类文件；
• JEP 460：向量 API（第七轮孵化），让你的向量运算更加高效；
• JEP 461：流聚合器（预览版），让你的流处理更加灵活；
• JEP 462：结构化并发（第二轮预览），让你的并发编程更加有序；
• JEP 464：作用域值（第二轮预览），让你的变量作用域更加清晰。

还有四个新特性是归在 Java 语言规范下面的：

• JEP 447：super(…) 前导语句（预览版），让你在调用父类构造方法之前能执行其他语句；
• JEP 456：未命名变量和模式，让你的代码更加简洁易读；
• JEP 459：字符串模板（第二轮预览），让你的字符串拼接更加优雅；
• JEP 463：隐式声明类和实例主方法（第二轮预览），让你的类和实例方法声明更加简洁。

另外，还有一个新特性是归在 HotSpot 下面的：

• JEP 423：G1 的区域锚定，让你的垃圾回收更加高效。

最后，还有一个新特性是归在 Java 工具下面的：

• JEP 458：启动多文件源码程序，让你能更加方便地运行多个源文件的程序。

这些新特性都被归类到了四个主要的 Java 项目里：Amber、Loom、Panama 和 Valhalla。这四个项目可是 Oracle 的亲儿子，专门负责孵化一系列组件，最后整合到 JDK 里去的。