Java19新特性

Java19新特性

JDK 19 定于 2022 年 9 月 20 日正式发布以供生产使用，非长期支持版本。不过，JDK 19 中有一些比较重要的新特性值得关注。

官方文档：OpenJDK Java 19 文档

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

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

JDK 19 只有 7 个新特性：

• JEP 405: Record Patterns（记录模式）（预览）
• JEP 422: JDK移植到Linux/RISC-V Port
• JEP 424: Foreign Function & Memory API（外部函数和内存 API）（预览）
• JEP 425: Virtual Threads（虚拟线程）（预览）
• JEP 426: Vector（向量）API（第四次孵化）
• JEP 427: Pattern Matching for switch（switch 模式匹配）（第三次预览）
• JEP 428: Structured Concurrency（结构化并发）（孵化）

JEP 405: Record Patterns（记录模式）（预览）

Record 是 Java 14 引入的，它主要目的是提供一种简洁的语法来声明类似数据的小型不可变对象，主要是为了解决长期以来在 Java 中定义纯数据载体类时，代码过于繁琐的问题。它的本质上是一个不可变的、透明的数据载体对象，我们可以理解它是一种特殊类型的 Java 类。定义 Record 方法如下：

public record User(String name,Integer age) {
}

Record 会自带 getters、equals()、hashCode() 和 toString() 方法，无需我们手写。

但是我们在使用类型匹配时仍然需要强制转换下，如下：

    public void recordTest(Object obj) {
        if (obj instanceof User) {
            User user = (User) obj;
            String name = user.name();
            Integer age = user.age();
        }
    }

这种做法无疑是繁琐的。还记得 Java 14 引入的模式匹配的 instanceof吗？它允许在 instanceof 操作符的条件判断中直接定义一个变量，如果对象是指定的类型，这个变量会被初始化为被检查的对象，可以立即使用，而无需额外的类型转换。这不就解决了我们的问题吗？

Java 19 引入模式匹配（Record Patterns），它允许我们通过模式匹配直接提取组件，而不需要先进行强制类型转换后再提取。它需要与 instanceof 或 switch 模式匹配一同使用。

我们先看 instanceof，改造如下：

    public void recordTest(Object obj) {
        if (obj instanceof User user) {
            String name = user.name();
            Integer age = user.age();
        }
    }

那在 Switch 表达式中呢，如下：

    public void recordTest(Object obj) {
        switch (obj) {
            case null -> throw new NullPointerException("不能为空");
            case User user -> System.out.println("name:" + user.name() + "--age:" + user.age());
            default -> obj.toString();
        }
    }

我们还可以将 User 的属性直接提取出来，如下：

    public void recordTest(Object obj) {
        switch (obj) {
            case null -> throw new NullPointerException("不能为空");
            case User(String name,Integer age) -> System.out.println("name:" + name + "--age:" + age);
            default -> obj.toString();
        }
    }

我们再衍生下，case User(String name,Integer age) 一定要这么写吗？我们都知道了它是 User 类型了，他的属性类型是不是就是固定的？还记得 Java 10 引入的局部变量类型推断么？我们可不可以用 var 来代替？其实是可以的：

    public void recordTest(Object obj) {
        switch (obj) {
            case null -> throw new NullPointerException("不能为空");
            case User(var name,var age) -> System.out.println("name:" + name + "--age:" + age);
            default -> obj.toString();
        }
    }

所以，在声明模式变量时，我们并不需要显式地指定类型，用 var 也行，具体的类型由编译器自动推断。

JEP 422: JDK移植到Linux/RISC-V Port

这个改动点的重点不是移植工作本身，它几乎已经完成，而是将端口集成到JDK主线存储库中。

JDK主线和RISC-V端口项目之间的当前差异可以通过以下方式获得：
$ git clone https://github.com/openjdk/riscv-port riscv-port
$ cd riscv-port
$ git diff master…riscv-port

JEP 424: Foreign Function & Memory API（外部函数和内存 API）（预览）

此功能已经过多次孵化。在Java 19中进行第一次预览。

Java 程序可以通过该 API 与 Java 运行时之外的代码和数据进行互操作。通过高效地调用外部函数（即 JVM 之外的代码）和安全地访问外部内存（即不受 JVM 管理的内存），该 API 使 Java 程序能够调用本机库并处理本机数据，而不会像 JNI 那样危险和脆弱。

在没有外部函数和内存 API 之前：

• Java 通过 sun.misc.Unsafe 提供一些执行低级别、不安全操作的方法（如直接访问系统内存资源、自主管理内存资源等），Unsafe 类让 Java 语言拥有了类似 C 语言指针一样操作内存空间的能力的同时，也增加了 Java 语言的不安全性，不正确使用 Unsafe 类会使得程序出错的概率变大。
• Java 1.1 就已通过 Java 原生接口（JNI）支持了原生方法调用，但并不好用。JNI 实现起来过于复杂，步骤繁琐，不受 JVM 的语言安全机制控制，影响 Java 语言的跨平台特性。并且，JNI 的性能也不行，因为 JNI 方法调用不能从许多常见的 JIT 优化(如内联)中受益。虽然JNA、JNR和JavaCPP等框架对 JNI 进行了改进，但效果还是不太理想。

引入外部函数和内存 API 就是为了解决 Java 访问外部函数和外部内存存在的一些痛点。

Foreign Function & Memory API (FFM API) 定义了类和接口：

• 分配外部内存：MemorySegment、、MemoryAddress和SegmentAllocator）；
• 操作和访问结构化的外部内存：MemoryLayout, VarHandle；
• 控制外部内存的分配和释放：MemorySession；
• 调用外部函数：Linker、FunctionDescriptor和SymbolLookup。

下面是 FFM API 使用示例，这段代码获取了 C 库函数的 radixsort 方法句柄，然后使用它对 Java 数组中的四个字符串进行排序。

// 1. 在C库路径上查找外部函数
Linker linker = Linker.nativeLinker();
SymbolLookup stdlib = linker.defaultLookup();
MethodHandle radixSort = linker.downcallHandle(stdlib.lookup("radixsort"), ...);
// 2. 分配堆上内存以存储四个字符串
String[] javaStrings   = { "mouse", "cat", "dog", "car" };
// 3. 分配堆外内存以存储四个指针
SegmentAllocator allocator = implicitAllocator();
MemorySegment offHeap  = allocator.allocateArray(ValueLayout.ADDRESS, javaStrings.length);
// 4. 将字符串从堆上复制到堆外
for (int i = 0; i < javaStrings.length; i++) {
    // 在堆外分配一个字符串，然后存储指向它的指针
    MemorySegment cString = allocator.allocateUtf8String(javaStrings[i]);
    offHeap.setAtIndex(ValueLayout.ADDRESS, i, cString);
}
// 5. 通过调用外部函数对堆外数据进行排序
radixSort.invoke(offHeap, javaStrings.length, MemoryAddress.NULL, '\0');
// 6. 将(重新排序的)字符串从堆外复制到堆上
for (int i = 0; i < javaStrings.length; i++) {
    MemoryAddress cStringPtr = offHeap.getAtIndex(ValueLayout.ADDRESS, i);
    javaStrings[i] = cStringPtr.getUtf8String(0);
}
assert Arrays.equals(javaStrings, new String[] {"car", "cat", "dog", "mouse"});  // true

JEP 425: Virtual Threads（虚拟线程）（预览）

这里单独开一篇文章：Java19新特性-虚拟线程（第一次预览）

JEP 426: Vector（向量）API（第四次孵化）

向量（Vector） API 最初由 JEP 338 提出，并作为孵化 API集成到 Java 16 中。第二轮孵化由 JEP 414 提出并集成到 Java 17 中，第三轮孵化由 JEP 417 提出并集成到 Java 18 中，第四轮由 JEP 426 提出并集成到了 Java 19 中。

向量计算由对向量的一系列操作组成。向量 API 用来表达向量计算，该计算可以在运行时可靠地编译为支持的 CPU 架构上的最佳向量指令，从而实现优于等效标量计算的性能。

向量 API 的目标是为用户提供简洁易用且与平台无关的表达范围广泛的向量计算。

这是对数组元素的简单标量计算：

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;
   }
}

这是使用 Vector API 进行的等效向量计算：

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 427: Pattern Matching for switch（switch 模式匹配）（第三次预览）

从 Java 17 开始，对于 Switch 的改进就已经在进行了，Java18进行了预览，具体可看Java18新特性

JEP 428: Structured Concurrency（结构化并发）（孵化）

JDK 19 引入了结构化并发，一种多线程编程方法，目的是为了通过结构化并发 API 来简化多线程编程，并不是为了取代java.util.concurrent，目前处于孵化器阶段。

结构化并发将不同线程中运行的多个任务视为单个工作单元，从而简化错误处理、提高可靠性并增强可观察性。也就是说，结构化并发保留了单线程代码的可读性、可维护性和可观察性。

结构化并发的基本 API 是StructuredTaskScope。StructuredTaskScope 支持将任务拆分为多个并发子任务，在它们自己的线程中执行，并且子任务必须在主任务继续之前完成。

StructuredTaskScope 的基本用法如下：

    try (var scope = new StructuredTaskScope<Object>()) {
        // 使用fork方法派生线程来执行子任务
        Future<Integer> future1 = scope.fork(task1);
        Future<String> future2 = scope.fork(task2);
        // 等待线程完成
        scope.join();
        // 结果的处理可能包括处理或重新抛出异常
        ... process results/exceptions ...
    } // close