关于后端:JDK21更新特性详解

有的时候博客内容会有变动，首发博客是最新的，其余博客地址可能会未同步, 认准https://blog.zysicyj.top

首发博客地址

文章更新打算

String Templates 是 Java 15 中引入的一个新个性，它容许咱们在字符串中应用占位符来动静替换变量的值。它提供了一种更简洁、更直观的形式来构建字符串，而不须要应用传统的字符串拼接或格式化办法。

在传统的 Java 中，咱们通常应用字符串拼接或格式化办法来构建动静字符串。这种形式须要手动解决变量的值，并且容易出错。而且，当字符串中蕴含大量变量时，代码会变得简短且难以保护。

String Templates 的引入解决了这个问题，它提供了一种更简洁、更易读的形式来构建动静字符串。通过应用占位符，咱们能够将变量的值间接嵌入到字符串中，而不须要手动解决。

String Templates 的实现原理是通过在字符串中应用占位符 ${} 来示意变量。在运行时，Java 编译器会将这些占位符替换为理论的变量值。

具体来说，当咱们应用 String Templates 时，编译器会将字符串中的占位符 ${}
解析为一个非凡的表达式，并将其转换为对应的变量值。这个过程是在编译时实现的，所以在运行时不会有额定的性能开销。

简洁易读 ：应用占位符${} 来示意变量，使得代码更加简洁、易读。
类型平安：String Templates 在编译时会进行类型查看，确保变量的类型与占位符的类型匹配，防止了运行时的类型谬误。
性能优化：String Templates 的解析过程是在编译时实现的，所以在运行时不会有额定的性能开销。
可扩展性：String Templates 反对自定义的格式化函数，能够依据需要进行扩大。

兼容性：String Templates 是 Java 15 中引入的新个性，须要应用 Java 15 或更高版本的 JDK 能力应用。
语法限度 ：String Templates 的占位符${} 只能用于示意变量，不能用于执行任意的表达式。
可读性：当字符串中蕴含大量的占位符时，可能会升高代码的可读性。

上面是一个应用 String Templates 的简略示例：

String name = "Alice";
int age = 25;
String message = "My name is ${name} and I'm ${age} years old.";
System.out.println(message);

输入后果为：

My name is Alice and I'm 25 years old.

占位符 ${} 中的变量名必须是无效的 Java 标识符。
占位符 ${} 中的变量值能够是任意类型，编译器会主动进行类型转换。
如果变量值为 null，占位符 ${} 会被替换为字符串 ”null”。
String Templates 反对嵌套应用，能够在占位符 ${} 中应用其余占位符。

String Templates 是 Java 15 中引入的一个新个性，它提供了一种更简洁、更直观的形式来构建动静字符串。通过应用占位符${}
，咱们能够将变量的值间接嵌入到字符串中，而不须要手动解决。String
Templates 具备简洁易读、类型平安、性能优化和可扩展性等长处，但也存在兼容性、语法限度和可读性等毛病。在应用 String
Templates 时，须要留神占位符的命名规定和变量值的类型。

Sequenced Collections 是 Java 中的一个新个性，它是通过 JEP 431 引入的。Sequenced
Collections 是一种新的汇合类型，它提供了一种有序的、线程平安的汇合实现。它的指标是提供一种高效的、可扩大的有序汇合，以满足在多线程环境下解决大量数据的需要。

在并发编程中，解决大量数据时，有序汇合是十分常见的需要。然而，Java 规范库中的汇合类（如 ArrayList、LinkedList 等）并不是线程平安的，因而在多线程环境下应用它们可能会导致数据不统一的问题。为了解决这个问题，开发人员通常须要应用同步机制（如 synchronized 关键字或 Lock 对象）来保障汇合的线程安全性，但这会带来额定的开销和复杂性。

Sequenced Collections 的指标就是提供一种高效的、可扩大的有序汇合，以解决在多线程环境下解决大量数据时的线程平安问题。

Sequenced Collections 的实现基于一种称为 ”Sequenced Locks” 的机制。Sequenced
Locks 是一种非凡的锁机制，它容许多个线程同时读取汇合中的数据，但只容许一个线程进行写操作。这种机制能够进步并发性能，同时保证数据的一致性。

在 Sequenced
Collections 中，每个元素都有一个惟一的序列号，用于标识元素的程序。读操作能够并发进行，而写操作则须要获取锁来保障原子性。当一个线程进行写操作时，其余线程能够持续读取汇合中的数据，但不能进行写操作，直到写操作实现。

线程平安：Sequenced Collections 提供了线程平安的汇合实现，能够在多线程环境下平安地拜访和批改汇合中的数据。
高效性能：Sequenced Collections 应用了 Sequenced Locks 机制，能够进步并发性能，同时保证数据的一致性。
可扩展性：Sequenced Collections 的设计思考了可扩展性，能够解决大量数据的并发拜访。

额定开销：Sequenced Collections 的实现须要保护元素的序列号和锁机制，这会带来肯定的额定开销。
写操作的提早：因为写操作须要获取锁来保障原子性，可能会导致其余线程在写操作实现之前无奈进行写操作。

上面是一个应用 Sequenced Collections 的简略示例：

import java.util.concurrent.SequencedHashMap;

public class SequencedCollectionsExample {public static void main(String[] args) {SequencedHashMap<Integer, String> map = new SequencedHashMap<>();

        // 增加元素
        map.put(1, "Apple");
        map.put(2, "Banana");
        map.put(3, "Orange");

        // 获取元素
        String fruit = map.get(2);
        System.out.println(fruit); // 输入: Banana

        // 遍历元素
        map.forEach((key, value) -> System.out.println(key + ":" + value));
        // 输入:
        // 1: Apple
        // 2: Banana
        // 3: Orange
    }
}

在下面的示例中，咱们应用了 SequencedHashMap 来创立一个有序的、线程平安的汇合。咱们能够应用 put 办法增加元素，应用 get 办法获取元素，应用 forEach 办法遍历元素。

Sequenced Collections 是 Java 规范库的一部分，从 Java 17 开始引入。
Sequenced Collections 提供了多种汇合类型，如 SequencedHashMap、SequencedArrayList 等。
Sequenced Collections 能够与其余 Java 汇合类（如 ArrayList、LinkedList 等）一起应用，以满足不同的需要。

Sequenced Collections 是 Java 中的一个新个性，它提供了一种有序的、线程平安的汇合实现。它通过应用 Sequenced
Locks 机制来保障线程安全性和并发性能。Sequenced Collections 具备高效性能、可扩展性等长处，但也存在额定开销和写操作提早的毛病。在应用 Sequenced
Collections 时，咱们能够创立 SequencedHashMap、SequencedArrayList 等汇合类型，并应用 put、get、forEach 等办法来操作汇合中的数据。

Generational ZGC（Z Garbage Collector）是一种用于 Java 虚拟机（JVM）的垃圾回收器。它是 OpenJDK 我的项目中的一个个性，旨在提供低提早和高吞吐量的垃圾回收解决方案。

传统的垃圾回收器在解决大型堆内存时可能会导致长时间的进展，这对于须要疾速响应和低提早的应用程序来说是不可承受的。Generational
ZGC 的指标是缩小这些进展工夫，并且可能解决十分大的堆内存。

Generational ZGC 基于分代垃圾回收的概念，将堆内存划分为多个代。其中包含 Young Generation（年老代）和 Old
Generation（老年代）。具体的实现原理如下：

年老代应用了 Region 的概念，将整个年老代划分为多个大小相等的区域。
每个区域都有一个指针指向下一个可用的区域，造成一个链表构造。
当对象被创立时，它们首先被调配到年老代的某个区域中。
当一个区域被填满时，会触发一次年老代垃圾回收（Minor GC）。
Minor GC 应用了并行和压缩算法来回收不再应用的对象。

老年代是寄存生命周期较长的对象的区域。
当一个对象在年老代经验了屡次垃圾回收后依然存活，它将被降职到老年代。
当老年代空间有余时，会触发一次老年代垃圾回收（Major GC）。
Major GC 应用了并发标记和并行清理算法来回收不再应用的对象。

Generational ZGC 采纳了并发解决的形式来缩小进展工夫。具体包含：

年老代垃圾回收过程中，应用程序能够继续执行。
在老年代垃圾回收过程中，应用程序也能够继续执行，只有在最初的清理阶段才会产生短暂的进展。

低提早：Generational ZGC 通过并发解决和分代回收的策略，实现了非常低的进展工夫，适宜对响应工夫要求高的利用场景。
高吞吐量：Generational ZGC 在尽可能减少进展工夫的同时，也能放弃较高的垃圾回收吞吐量。
大堆反对：Generational ZGC 能够解决十分大的堆内存，实用于须要大内存容量的应用程序。

性能开销：因为并发解决和分代回收的策略，Generational ZGC 会带来肯定的性能开销。这次要体现在 CPU 和内存的应用上。
配置简单：Generational ZGC 有一些与性能相干的配置参数，须要依据具体场景进行调整，对于不相熟的用户来说可能比较复杂。

以下是一个简略的 Java 代码示例，展现了如何启用 Generational ZGC：

java -XX:+UnlockExperimentalVMOptions -XX:+UseZGC YourApplication

Generational ZGC 是 OpenJDK 我的项目中的新个性，尽管曾经相当稳固，但依然倡议在生产环境中进行充沛测试。
在应用 Generational ZGC 时，倡议监控系统资源应用状况，以便及时调整配置参数或采取其余措施来优化性能。

Generational ZGC 是一种用于 Java 虚拟机的垃圾回收器，旨在提供低提早和高吞吐量的垃圾回收解决方案。它通过并发解决和分代回收的策略，实现了非常低的进展工夫，并且可能解决十分大的堆内存。然而，应用 Generational
ZGC 须要留神性能开销和配置复杂性。

Record Patterns 是 Java 16 中引入的一个新个性，它容许咱们在模式匹配中应用记录类型（record
types）。记录类型是一种新的类申明模式，用于定义不可变的数据对象。而 Record Patterns 则提供了一种简洁的形式来进行模式匹配，并且能够不便地从记录类型中提取字段值。

在传统的 Java 编程中，当咱们须要对某个对象的属性进行判断和提取时，通常须要手动编写大量的代码来实现这些操作。而引入 Record
Patterns 能够极大地简化这个过程，使得代码更加清晰、简洁，并且缩小了出错的可能性。

Record Patterns 的实现原理次要波及两个方面：记录类型和模式匹配。

记录类型是一种新的类申明模式，通过 record 关键字来定义。它主动提供了以下性能：

主动生成公有 final 字段，并依据结构函数参数初始化这些字段。
主动生成 equals()、hashCode() 和 toString() 办法。
提供了一种紧凑的语法来定义字段和构造函数。

模式匹配是指依据给定的模式来匹配某个对象，并执行相应的操作。在 Record Patterns 中，咱们能够应用 instanceof
关键字和模式变量来进行模式匹配。

具体地说，当咱们应用 Record Patterns
进行模式匹配时，编译器会主动为记录类型生成一个模式匹配办法。这个办法承受一个对象作为参数，并依据给定的模式进行匹配。如果匹配胜利，则将字段值绑定到相应的模式变量中，从而能够在后续代码中应用。

Record Patterns 带来了以下几个长处：

简洁性：应用 Record Patterns 能够大大简化对记录类型的模式匹配操作，缩小冗余代码。
可读性：Record Patterns 提供了一种直观、清晰的语法，使得代码更易于了解和保护。
安全性：因为 Record Patterns 主动生成了 equals() 和 hashCode() 办法，能够防止手动实现这些办法时可能呈现的谬误。
进步开发效率：Record Patterns 能够缩小重复劳动，进步开发效率。

只管 Record Patterns 带来了很多益处，但也存在一些限度和毛病：

不可变性：记录类型是不可变的，即字段值不能被批改。这意味着如果须要批改某个字段的值，就必须创立一个新的记录对象。
局限性：Record Patterns 目前只能用于记录类型，不能用于其余类。
兼容性：因为 Record Patterns 是在 Java 16 中引入的新个性，因而须要应用 Java 16 或更高版本能力应用。

上面是一个简略的示例，展现了如何应用 Record Patterns 进行模式匹配：

record Person(String name, int age) {}

public class Main {public static void main(String[] args) {Person person = new Person("Alice", 25);

        if (person instanceof Person p) {System.out.println(p.name()); // 输入 "Alice"
            System.out.println(p.age()); // 输入 25
        }
    }
}

在上述示例中，咱们定义了一个名为 Person 的记录类型，并创立了一个 Person 对象。而后，咱们应用 Record Patterns
进行模式匹配，将字段值绑定到模式变量 p 中，并输入字段值。

在应用 Record Patterns 时，须要留神以下几点：

记录类型的字段默认是 final 的，即不能被批改。如果须要批改某个字段的值，就必须创立一个新的记录对象。
记录类型的结构函数参数和字段名称要统一，否则会导致编译谬误。
模式匹配办法的命名规定是 match<RecordTypeName>，例如 matchPerson()。

Record Patterns 是 Java 16 引入的一个新个性，它提供了一种简洁、清晰的形式来进行模式匹配，并且能够不便地从记录类型中提取字段值。应用
Record Patterns 能够使代码更加简洁、可读，并进步开发效率。然而，因为记录类型是不可变的，因而在批改字段值时须要创立新的对象。同时，Record
Patterns 目前只能用于记录类型，不能用于其余类。

Pattern Matching for switch 是 Java 14 中引入的一个新个性，它容许在 switch 语句中应用模式匹配。通过这个个性，咱们能够更不便地对变量进行类型判断和提取。

在之前的 Java 版本中，如果咱们想要依据不同的类型执行不同的逻辑，通常须要应用多个 if-else 或者 switch-case
来进行判断。这样的代码构造比拟简短，并且容易出错。而 Pattern Matching for switch 的引入，使得咱们可能更简洁、清晰地解决这种状况。

Pattern Matching for switch 的实现原理次要波及两个方面：模式匹配和类型推断。

模式匹配是指将某个值与一系列模式进行比拟，以确定是否匹配。在 Pattern Matching for switch 中，咱们能够应用关键字 case
后跟上模式来进行匹配。例如：

int result = switch (obj) {case String s -> s.length();
    case Integer i -> i * 2;
    default -> -1;
};

在上述代码中，case String s 和 case Integer i 就是模式，它们别离用于匹配字符串和整数类型的对象。

类型推断是指依据上下文信息，主动推断出某个表达式的类型。在 Pattern Matching for switch 中，咱们能够应用 var
关键字来进行类型推断。例如：

int result = switch (obj) {case String s -> s.length();
    case Integer i -> i * 2;
    default -> -1;
};

在上述代码中，var 关键字用于推断 result 的类型为 int。

简化了对变量类型的判断和提取逻辑，使代码更加简洁、清晰。
缩小了反复的代码，进步了开发效率。
加强了代码的可读性和可维护性。

只能用于 switch 语句中，不能间接用于 if-else 构造。
目前只反对根本数据类型和援用类型的模式匹配，不反对其余非凡类型（如枚举、数组等）的模式匹配。

上面是一个应用 Pattern Matching for switch 的示例代码：

public static void process(Object obj) {switch (obj) {case String s -> System.out.println("String:" + s);
        case Integer i -> System.out.println("Integer:" + i);
        case Double d -> System.out.println("Double:" + d);
        default -> System.out.println("Unknown type");
    }
}

在上述代码中，依据传入的对象类型不同，会执行相应的逻辑。

模式匹配是依照 case 的程序进行匹配的，因而须要将更具体的模式放在后面。
如果没有匹配到任何模式，则会执行 default 分支的逻辑。
在一个 switch 块外部，每个模式只能呈现一次，否则会编译报错。

Pattern Matching for switch 是 Java 14 中引入的一个新个性，它容许在 switch
语句中应用模式匹配。通过这个个性，咱们能够更不便地对变量进行类型判断和提取。它简化了对变量类型的判断和提取逻辑，使代码更加简洁、清晰，并且加强了代码的可读性和可维护性。但须要留神的是，目前只反对根本数据类型和援用类型的模式匹配，不反对其余非凡类型的模式匹配。

Foreign Function & Memory API 是 Java 平台的一个性能，它容许开发者间接与本地代码进行交互，并且能够在 Java 中操作本地内存。这个性能最后在
JDK 14 的时候以 JEP 383 的模式引入了第一次预览版，而后在 JDK 15 中进一步改良并公布了第二次预览版（JEP 393），当初在 JDK 21
中公布了第三次预览版（JEP 442）。

Foreign Function & Memory API 的呈现次要是为了解决以下几个问题：

与本地代码的无缝集成：有些场景下，咱们可能须要调用本地库或者零碎级别的函数，例如应用硬件加速、调用底层操作系统的特定性能等。而
Foreign Function & Memory API 能够使得 Java 程序可能间接调用本地函数，从而实现与本地代码的无缝集成。
进步性能：通过间接操作本地内存，能够防止数据拷贝和类型转换带来的性能损耗，从而进步程序的执行效率。
扩大现有 Java 库的性能：Foreign Function & Memory API 提供了一种机制，能够将本地库中的函数包装成 Java 接口，从而不便地扩大现有的
Java 库的性能。

Foreign Function & Memory API 的实现次要依赖于以下几个关键技术：

JNI（Java Native Interface）：JNI 是 Java 平台提供的一种机制，用于在 Java 程序中调用本地代码。Foreign Function & Memory
API 利用 JNI 提供的能力，使得 Java 程序能够间接调用本地函数。
内存治理：Foreign Function & Memory API 容许开发者间接操作本地内存，包含调配、开释和读写等操作。这须要对内存进行无效的治理，以确保安全性和可靠性。
类型映射 ：因为 Java 和本地代码应用不同的数据类型示意数据，因而须要进行类型映射。Foreign Function & Memory API
提供了一套规定和工具，用于将 Java 类型与本地类型进行转换。

无缝集成：Foreign Function & Memory API 能够使得 Java 程序可能间接调用本地函数，从而实现与本地代码的无缝集成。
高性能：通过间接操作本地内存，防止了数据拷贝和类型转换带来的性能损耗，从而进步程序的执行效率。
灵活性：Foreign Function & Memory API 提供了丰盛的性能和灵便的接口，能够满足不同场景下的需要。

安全性危险：间接操作本地内存可能会带来一些平安危险，例如内存透露、拜访非法内存等。因而，在应用 Foreign Function &
Memory API 时须要审慎解决，并遵循相干的平安标准。
复杂性：Foreign Function & Memory API 波及到与本地代码的交互和内存治理等简单的问题，对开发者的要求较高，须要具备肯定的底层编程常识和教训。

以下是一个简略的示例，展现了如何应用 Foreign Function & Memory API 调用本地函数：

import jdk.incubator.foreign.*;

public class NativeFunctionExample {public static void main(String[] args) throws Exception {try (MemorySegment segment = MemorySegment.allocateNative(4)) {CLinker linker = CLinker.getInstance();
            FunctionDescriptor descriptor = FunctionDescriptor.of(CLinker.C_INT, CLinker.C_POINTER);
            LibraryLookup lookup = LibraryLookup.ofDefault();
            Symbol symbol = lookup.lookup("printf");
            FunctionHandle handle = linker.downcallHandle(symbol, descriptor);

            String message = "Hello, World!";
            MemoryAccess.setCString(segment.baseAddress(), message);
            int result = (int) handle.invokeExact(segment.baseAddress());

            System.out.println("Result:" + result);
        }
    }
}

上述示例中，咱们应用 Foreign Function & Memory API 调用了本地的 printf 函数，并将后果打印进去。

在应用 Foreign Function & Memory API 时，须要确保本地函数和库曾经正确装置并可用。
对于间接操作本地内存的状况，须要特地留神内存治理和安全性问题，避免出现内存透露、拜访非法内存等问题。
应用 Foreign Function & Memory API 须要审慎解决异样，以确保程序的稳定性和可靠性。

Foreign Function & Memory API 是 Java 平台提供的一种机制，能够使得 Java 程序可能间接调用本地函数，并且能够在 Java
中操作本地内存。它通过 JNI 技术实现与本地代码的无缝集成，并提供了高性能和灵活性。然而，在应用 Foreign Function & Memory API
时须要留神安全性和复杂性等问题，以确保程序的稳定性和可靠性。

Unnamed Patterns and Variables 是 Java 编程语言的一个新个性，它在 JDK 14 中引入，并在 JDK 15
中作为预览性能持续存在。该个性容许咱们应用匿名模式和变量来简化代码并进步可读性。

在传统的 Java 代码中，当咱们须要对某个对象进行模式匹配时，通常须要创立一个长期变量来存储匹配后果。这样会导致代码简短、可读性差，并且减少了不必要的命名累赘。

而 Unnamed Patterns and Variables 的呈现正是为了解决这个问题。通过应用匿名模式和变量，咱们能够间接在模式匹配表达式中应用，防止了创立长期变量的麻烦，使得代码更加简洁和易于了解。

Unnamed Patterns and Variables 的实现原理次要波及两个方面：匿名模式和匿名变量。

匿名模式是一种非凡的模式，用于示意咱们只关怀某个值是否满足某个条件，而不关怀具体的值是什么。在匿名模式中，咱们应用下划线 _
来代替具体的变量名。

例如，咱们能够应用匿名模式来判断一个对象是否为 null：

if (obj instanceof String _) {System.out.println("obj is a non-null string");
}

匿名变量是一种非凡的变量，用于示意咱们不须要应用该变量的值。在匿名变量中，咱们同样应用下划线 _ 来代替具体的变量名。

例如，在 switch 语句中，咱们能够应用匿名变量来疏忽某些分支的返回值：

switch (dayOfWeek) {case MONDAY, TUESDAY, WEDNESDAY, THURSDAY -> System.out.println("Weekday");
    case FRIDAY -> System.out.println("Friday");
    case SATURDAY, SUNDAY -> System.out.println("Weekend");
    default -> throw new IllegalArgumentException("Invalid day of week:" + dayOfWeek);
}

简化代码：通过应用匿名模式和变量，能够缩小长期变量的创立，使得代码更加简洁。
进步可读性：匿名模式和变量可能间接表白咱们关怀的条件，防止了命名的繁琐，使得代码更易于了解。

因为 Unnamed Patterns and Variables 目前仍处于预览阶段，因而存在以下一些限度和潜在问题：

兼容性问题：因为该个性是在 JDK 14 中引入的，并且仍处于预览阶段，因而可能存在与旧版本 Java 不兼容的问题。
语法限度：匿名模式和变量只能用于某些特定的上下文中，不能在所有中央应用。例如，在 lambda 表达式、办法援用等场景中临时还无奈应用。

以下是一个应用匿名模式和变量的示例代码，用于判断一个对象是否为非空字符串：

if (obj instanceof String _) {System.out.println("obj is a non-null string");
}

在应用 Unnamed Patterns and Variables 时，须要留神以下几点：

匿名模式和变量只能用于示意咱们不关怀具体值的状况，如果须要获取具体的值，则应该应用一般的命名模式和变量。
在一些非凡的上下文中，如 lambda 表达式、办法援用等，目前还无奈应用匿名模式和变量。

Unnamed Patterns and Variables 是 Java
编程语言的一个新个性，它通过引入匿名模式和变量来简化代码并进步可读性。尽管该个性目前仍处于预览阶段，并存在一些限度和潜在问题，但它为咱们编写更简洁、易读的代码提供了一种新的形式。

Virtual Threads（虚构线程）是 Java 平台的一项新性能，它旨在改良 Java 中的并发编程模型。传统上，Java 应用基于操作系统线程的并发模型，每个线程都须要调配一个操作系统线程来执行。而 Virtual
Threads 则提供了一种更高效、更轻量级的线程模型。

在传统的基于操作系统线程的并发模型中，创立和销毁线程以及在线程之间切换的开销很大。这限度了 Java 应用程序在解决大规模并发时的性能和扩展性。此外，因为操作系统线程的数量无限，当应用程序须要创立大量线程时，可能会导致资源耗尽或者性能降落。

Virtual
Threads 的呈现解决了这些问题。它通过引入一种轻量级的线程模型，能够在 Java 应用程序中创立数百万甚至数十亿个线程，而不会受到操作系统线程数量的限度。这使得 Java 应用程序可能更好地适应大规模并发场景，并提供更高的性能和可伸缩性。

Virtual Threads 的实现依赖于 Java 虚拟机（JVM）的合作调度器和 Fork/Join 框架。它通过将多个 Virtual
Threads 映射到大量的操作系统线程上来实现高效的并发执行。

具体而言，当一个 Java 应用程序创立一个 Virtual
Thread 时，JVM 会为其调配一个虚构线程（也称为轻量级线程）。这些虚构线程由合作调度器治理，并在须要时与操作系统线程进行绑定。合作调度器负责决定哪个虚构线程能够运行以及何时切换虚构线程。

Fork/Join 框架是 Virtual Threads 的另一个要害组件。它提供了一种工作并行编程模型，容许开发人员将工作分解成更小的子工作，并应用工作窃取算法来实现负载平衡。Virtual
Threads 利用 Fork/Join 框架的能力，在不同的虚构线程之间主动地、通明地进行工作划分和调度。

更高的性能：Virtual Threads 缩小了线程创立和销毁的开销，同时防止了操作系统线程数量的限度，从而提供更高的性能。
更好的可伸缩性：因为 Virtual Threads 能够创立数百万甚至数十亿个线程，因而 Java 应用程序能够更好地适应大规模并发场景，并具备更好的可伸缩性。
更低的资源耗费：相比于操作系统线程，Virtual Threads 是轻量级的，占用更少的内存和 CPU 资源。

尽管 Virtual Threads 带来了许多劣势，但也存在一些潜在的毛病：

学习老本较高：应用 Virtual Threads 须要对并发编程模型有肯定的了解，并且须要适应新的 API 和开发范式。
可能引入新的问题：因为 Virtual Threads 是一个绝对较新的性能，可能会存在一些未知的问题或者不稳定性。

上面是一个简略的应用 Virtual Threads 的示例代码：

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class VirtualThreadsExample {public static void main(String[] args) {ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newVirtualThreadExecutor();

        for (int i = 0; i < 10; i++) {
            int taskId = i;
            executor.execute(() -> {System.out.println("Task" + taskId + "is running on virtual thread:" + Thread.currentThread().getName());
            });
        }

        executor.shutdown();}
}

上述示例中，咱们应用 Executors.newVirtualThreadExecutor() 办法创立了一个 ThreadPoolExecutor 实例，该实例能够执行 Virtual
Threads。而后，咱们通过调用 execute() 办法提交了一系列工作，每个工作都会打印以后运行的虚构线程的名称。

在应用 Virtual Threads 时，须要留神以下几点：

尽管 Virtual Threads 能够创立大量线程，但过多的线程仍可能导致性能降落或资源耗尽。因而，在设计应用程序时，仍需正当管制并发度。
应用 Virtual Threads 时，须要遵循良好的并发编程实际，如防止共享可变状态、应用适当的同步机制等，以确保线程安全性和正确性。
在迁徙现有代码到应用 Virtual Threads 时，须要进行肯定的重构和调整，以适应新的 API 和开发范式。

Virtual Threads 是 Java 平台的一项新性能，旨在改良 Java 中的并发编程模型。它通过引入轻量级的虚构线程，并利用合作调度器和 Fork/Join 框架来提供高效的并发执行。Virtual
Threads 具备更高的性能、更好的可伸缩性和较低的资源耗费，但也须要学习老本较高，并且可能存在一些潜在的问题。在应用 Virtual
Threads 时，须要留神正当管制并发度、遵循并发编程实际，并进行必要的重构和调整。

“Unnamed Classes and Instance Main Methods” 是一个 Java 编程语言的新个性，它在 JDK 14 中引入，并在 JDK 15
中成为预览性能。该个性容许咱们在类中定义匿名类和实例主办法。

在传统的 Java 编程中，咱们只能在顶级类或动态外部类中定义 main 办法作为程序的入口点。而应用 “Unnamed Classes and Instance
Main Methods” 个性后，咱们能够在任何类的实例中定义 main 办法，从而使得程序的入口点更加灵便。

传统的 Java 程序必须将 main
办法定义在顶级类或动态外部类中，这限度了程序的构造和组织形式。有时候，咱们可能心愿将多个相干的逻辑封装在同一个类的实例中，以进步代码的可读性和可维护性。而 “
Unnamed Classes and Instance Main Methods” 个性正是为了满足这种需要而引入的。

通过在类的实例中定义 main 办法，咱们能够更好地组织和管理程序的逻辑，缩小顶级类和动态外部类的数量，使代码更加清晰和易于了解。

“Unnamed Classes and Instance Main Methods” 个性的实现原理波及到两个方面：匿名类和实例主办法。

在 Java 中，咱们能够应用匿名类来创立一个没有显式名称的类。匿名类通常用于创立长期的、只须要一次应用的类对象。它们能够继承自某个类或实现某个接口，并重写其中的办法。

匿名类的语法如下：

new 父类结构器(参数列表) {// 匿名类的成员变量和办法定义}

传统的 Java 程序入口点是通过动态 main 办法来定义的，而 “Unnamed Classes and Instance Main Methods” 个性容许咱们在类的实例中定义
main 办法。

实例主办法的语法如下：

public void main(String[] args) {// 主办法的代码逻辑}

灵活性：通过在类的实例中定义 main 办法，程序的入口点更加灵便，能够依据需要将多个相干的逻辑封装在同一个类的实例中。
可读性：将相干的逻辑组织在同一个类的实例中，使得代码更加清晰和易于了解。
可维护性：缩小顶级类和动态外部类的数量，简化代码构造，进步代码的可维护性。

语法简单：匿名类和实例主办法的语法绝对传统的 main 办法更加简单，须要额定的学习老本。
可读性升高：如果滥用该个性，将多个逻辑封装在同一个类的实例中可能会导致代码可读性降落。

上面是一个应用 “Unnamed Classes and Instance Main Methods” 个性的示例：

public class Example {public static void main(String[] args) {new Example().main(args);
    }

    public void main(String[] args) {System.out.println("Hello, World!");
    }
}

在上述示例中，咱们定义了一个名为 Example 的类，并在其中创立了一个实例。通过调用实例的 main
办法，程序的入口点被指定为该实例的 main 办法。

在应用 “Unnamed Classes and Instance Main Methods” 个性时，须要确保每个类的实例只有一个 main 办法，否则编译器将无奈确定程序的入口点。
匿名类和实例主办法的语法较为简单，须要认真了解并遵循正确的语法规定。
尽管 “Unnamed Classes and Instance Main Methods” 个性在 JDK 15 中成为预览性能，但依然存在一些潜在的问题和限度。在应用时须要留神这些问题，并及时反馈给开发团队。

“Unnamed Classes and Instance Main Methods” 是 Java
编程语言的一个新个性，它容许咱们在类的实例中定义匿名类和实例主办法。通过该个性，咱们能够更灵便地组织程序的逻辑，进步代码的可读性和可维护性。然而，应用该个性须要留神语法复杂性和可读性升高的问题，并遵循正确的应用形式。

Scoped Values (Preview) 是 Java 平台的一个新个性，它在 JDK 17 中引入。该个性旨在提供一种机制，用于在代码块级别上设置和应用长期变量。

在传统的 Java 编程中，咱们通常会将变量申明在办法或类的作用域内，并且这些变量的生命周期与其所在的作用域雷同。然而，在某些状况下，咱们可能心愿在更小的范畴内定义长期变量，以便更好地管制其可见性和生命周期。

Scoped Values (Preview) 提供了一种简洁、平安的形式来定义和应用长期变量，使得代码更加清晰易读，并且能够缩小不必要的命名抵触和资源透露问题。

Scoped Values (Preview) 的实现基于 Java 语言标准中的局部变量类型推断（Local Variable Type Inference）机制。通过应用 var
关键字，咱们能够在代码块外部申明长期变量，并依据初始化表达式的类型进行类型推断。

例如，以下示例展现了如何应用 Scoped Values (Preview) 申明和应用长期变量：

void exampleMethod() {// 应用 Scoped Values (Preview) 申明长期变量
    var message = "Hello, World!";

    // 在代码块外部应用长期变量
    if (message.length() > 10) {System.out.println(message);
    }
}

在上述示例中，咱们应用 Scoped Values (Preview) 申明了一个名为 message 的长期变量，并将其初始化为字符串 “Hello, World!”
。而后，在 if 语句的代码块外部，咱们能够间接应用该长期变量。

简洁性：Scoped Values (Preview) 提供了一种更简洁的形式来申明和应用长期变量，缩小了冗余的代码。
可读性：通过在代码块级别上定义长期变量，使得代码更加清晰易读，进步了代码的可维护性。
类型平安：Scoped Values (Preview) 基于 Java 语言标准中的局部变量类型推断机制，确保了变量的类型安全性。

只管 Scoped Values (Preview) 提供了许多长处，但也存在一些潜在的毛病：

兼容性问题：因为 Scoped Values (Preview) 是 JDK 17 中引入的新个性，因而在较旧版本的 Java 中无奈应用。
学习老本：对于不相熟局部变量类型推断机制的开发人员来说，可能须要一些工夫来适应 Scoped Values (Preview) 的应用形式。

以下是一个应用 Scoped Values (Preview) 的简略示例：

void printMessage() {
    var message = "Hello, World!";
    System.out.println(message);
}

在上述示例中，咱们应用 Scoped Values (Preview) 申明了一个名为 message 的长期变量，并将其初始化为字符串 “Hello, World!”
。而后，咱们通过调用 System.out.println 办法打印该长期变量的值。

在应用 Scoped Values (Preview) 时，须要留神以下几点：

作用域限度：Scoped Values (Preview) 申明的长期变量仅在以后代码块外部可见，超出该代码块范畴后将无法访问。
类型推断：因为 Scoped Values (Preview) 是基于局部变量类型推断机制实现的，因而必须确保初始化表达式具备明确的类型信息，以便进行正确的类型推断。
命名抵触：当在同一代码块内应用多个 Scoped Values (Preview) 申明长期变量时，须要防止命名抵触，免得引起混同和谬误。

Scoped Values (Preview) 是 Java 平台的一个新个性，它提供了一种在代码块级别上设置和应用长期变量的机制。通过应用 var
关键字，咱们能够在代码块外部申明长期变量，并依据初始化表达式的类型进行类型推断。Scoped Values (Preview)
的长处包含简洁性、可读性和类型安全性，但也存在兼容性问题和学习老本。在应用 Scoped Values (Preview)
时，须要留神作用域限度、类型推断和命名抵触等注意事项。

Vector API (Sixth Incubator) 是 Java 平台的一个我的项目，旨在提供一种简略且高效的形式来执行向量化计算。它引入了新的类和接口，以反对应用
SIMD（Single Instruction, Multiple Data）指令集进行并行计算。

在许多应用程序中，存在大量的数据并行计算工作，例如图像处理、科学计算和机器学习等畛域。传统的 Java
编程模型无奈充分利用古代硬件的并行计算能力，导致性能低下。而 Vector API (Sixth Incubator) 的指标就是通过向量化计算来进步这些应用程序的性能。

Vector API (Sixth Incubator) 基于 SIMD 指令集，即单指令多数据流指令集。SIMD 指令集能够同时对多个数据元素执行雷同的操作，从而实现并行计算。Vector
API (Sixth Incubator) 提供了一组新的类和接口，使开发人员可能间接编写基于 SIMD 指令集的代码。

具体来说，Vector API (Sixth Incubator) 引入了 java.util.vector 包，其中蕴含了一些新的类和接口，如 Vector、FloatVector
和 IntVector 等。这些类提供了一组向量化操作方法，例如加法、减法、乘法等，以及对应的掩码操作。

在底层实现上，Vector API (Sixth Incubator) 应用了特定硬件平台的 SIMD 指令集来执行向量化计算。具体实现细节会依赖于不同的硬件架构和操作系统。

进步性能：通过利用 SIMD 指令集进行并行计算，能够显著进步应用程序的性能。
简化编程模型：Vector API (Sixth Incubator) 提供了一组简略易用的类和接口，使开发人员可能间接编写基于 SIMD 指令集的代码，而无需手动优化。

平台限度：Vector API (Sixth Incubator) 的实现依赖于特定的硬件平台和操作系统，因而在不同的平台上可能存在兼容性问题。
学习老本：应用 Vector API (Sixth Incubator) 须要学习新的类和接口，并了解 SIMD 指令集的工作原理，对于一些开发人员来说可能须要破费肯定的工夫和精力。

上面是一个简略的应用 Vector API (Sixth Incubator) 进行向量化计算的示例：

import java.util.vector.*;

public class VectorExample {public static void main(String[] args) {
        int size = 8;

        // 创立两个向量对象
        FloatVector a = FloatVector.broadcast(size, 2.0f);
        FloatVector b = FloatVector.broadcast(size, 3.0f);

        // 执行向量化加法操作
        FloatVector result = a.add(b);

        // 输入后果
        float[] array = new float[size];
        result.intoArray(array, 0);
        for (float value : array) {System.out.println(value);
        }
    }
}

在上述示例中，咱们创立了两个长度为 8 的浮点数向量，并执行了向量化的加法操作。最初将后果输入到数组中并打印进去。

硬件兼容性：因为 Vector API (Sixth Incubator) 的实现依赖于特定的硬件平台和操作系统，因而在应用之前须要确保指标平台反对
SIMD 指令集。
性能优化：尽管 Vector API (Sixth Incubator) 能够进步应用程序的性能，但要获得最佳性能还须要进行适当的优化。例如，防止频繁的向量化操作和数据拷贝等。

Vector API (Sixth Incubator) 是 Java 平台的一个我的项目，旨在提供一种简略且高效的形式来执行向量化计算。它基于 SIMD
指令集，并通过引入新的类和接口来反对并行计算。应用 Vector API (Sixth Incubator) 能够进步应用程序的性能，但须要留神硬件兼容性和适当的性能优化。

名字太长了。。前面简称 449

JEP 449（Java Enhancement Proposal 449）是一个针对 OpenJDK 的提案，旨在废除并最终移除 Windows 32 位 x86 平台上的 Java 反对。

次要有以下几个起因：

过期的硬件和操作系统：Windows 32 位 x86 平台曾经逐步被淘汰，古代计算机广泛采纳 64 位架构。同时，大多数新版本的 Windows 操作系统也只提供了 64 位版本。
性能限度：32 位架构限度了可寻址内存空间的大小，导致无奈充分利用古代计算机的资源。而 64 位架构能够提供更大的内存地址空间，从而进步应用程序的性能和扩展性。
平安问题：32 位架构存在一些安全漏洞和限度，例如缓冲区溢出等。而 64 位架构通过引入更多的爱护机制来减少应用程序的安全性。

基于以上起因，废除 Windows 32 位 x86 平台上的 Java 反对是正当且必要的。

JEP 449 的实现原理波及到编译器、虚拟机和库等多个方面的改变。

编译器层面：废除 32 位 x86 平台上的 Java 反对须要对编译器进行批改，禁止生成 32 位 x86 架构的指标代码。
虚拟机层面：虚拟机须要对内存治理、垃圾回收等进行调整，以适应 64 位架构的个性。同时，还须要更新与操作系统交互的局部代码，确保在 64 位环境下失常运行。
库层面：一些与硬件相干的库可能须要从新编写或者替换为 64 位版本，以充分利用 64 位架构的劣势。

具体实现细节能够参考 JEP 449 提案中的具体阐明。

性能晋升：64 位架构能够提供更大的内存地址空间，从而进步应用程序的性能和扩展性。
平安加强：64 位架构引入了更多的爱护机制，进步了应用程序的安全性。
与古代计算机趋势相符：Windows 32 位 x86 平台曾经逐步被淘汰，废除该平台上的 Java 反对是与时俱进的动作。

向后兼容性问题：废除 Windows 32 位 x86 平台上的 Java 反对可能导致一些现有的应用程序无奈在该平台上运行。这须要开发人员进行相应的迁徙和调整。
** 对于依然应用 32 位硬件和操作系统的用户而言，将无奈持续取得新版本的 Java 更新和性能改良。

JEP 449 是一个 OpenJDK 的提案，它次要影响到 OpenJDK 的开发者和 Windows 32 位 x86 平台上的 Java 用户。对于开发者来说，他们须要依据 JEP
449 的施行状况，适时地迁徙和调整本人的利用程序代码。对于 Windows
32 位 x86 平台上的 Java 用户来说，他们须要思考降级到 64 位架构的计算机和操作系统，以持续取得最新的 Java 更新和性能改良。

开发者须要及时关注 JEP 449 的施行状况，并依据须要进行相应的迁徙和调整。
Windows 32 位 x86 平台上的 Java 用户须要思考降级到 64 位架构的计算机和操作系统，以持续取得最新的 Java 更新和性能改良。

JEP 449 旨在废除并最终移除 Windows
32 位 x86 平台上的 Java 反对。这是基于该平台曾经逐步被淘汰、性能限度和平安问题等起因做出的正当动作。废除该平台上的 Java 反对能够进步应用程序的性能和安全性，并与古代计算机趋势相符。开发者须要及时关注 JEP
449 的施行状况，并依据须要进行相应的迁徙和调整。Windows 32 位 x86 平台上的 Java 用户须要思考降级到 64 位架构的计算机和操作系统，以持续取得最新的 Java 更新和性能改良。

动静加载代理禁用筹备（Prepare to Disallow the Dynamic Loading of
Agents）是一个 Java 加强提案，其指标是在 JVM 中禁止动静加载代理。代理是一种可能批改或监督应用程序行为的机制，它能够通过字节码注入来实现。

动静加载代理容许开发人员在运行时批改和监督 Java 应用程序的行为。尽管这对于调试和性能剖析等方面十分有用，但也存在潜在的平安危险。恶意代码可能会利用动静加载代理的性能来执行歹意操作，例如窃取敏感信息、篡改数据等。

因而，为了增强 Java 应用程序的安全性，限度动静加载代理的应用是很有必要的。

动静加载代理禁用筹备的实现波及到以下几个方面：

该提案倡议批改 Java 虚拟机的类加载器，以阻止动静加载代理。具体而言，将在 java.lang.ClassLoader
类中增加一个新的办法boolean disallowDynamicAgentLoading()，默认返回false。当该办法被调用时，将返回true，示意禁止动静加载代理。

为了反对 ClassLoader 的批改，还须要对 Java 虚拟机的 Instrumentation
API 进行相应的更改。具体而言，将在 java.lang.instrument.Instrumentation
接口中增加一个新的办法 boolean isDynamicAgentLoadingAllowed()，默认返回true。当该办法返回false 时，示意禁止动静加载代理。

此外，还倡议更新 Java 虚拟机的平安管理器（SecurityManager），以容许查看是否容许动静加载代理。这样能够通过安全策略来管制哪些代码能够应用动静加载代理性能。

进步 Java 应用程序的安全性：禁止动静加载代理能够避免恶意代码利用其性能执行潜在的危险操作。
简化平安配置：通过更新平安管理器和类加载器，能够更不便地管制动静加载代理的应用权限，简化平安配置过程。

可能影响现有代码：如果现有代码依赖于动静加载代理的性能，那么禁用它可能会导致这些代码无奈失常工作。因而，在利用该加强提案之前，须要认真评估现有代码的依赖关系。

以下是一个简略的示例，展现了如何应用动静加载代理禁用筹备：

import java.lang.instrument.Instrumentation;

public class AgentLoader {public static void premain(String agentArgs, Instrumentation inst) {
        // 禁止动静加载代理
        if (inst.isDynamicAgentLoadingAllowed()) {throw new SecurityException("Dynamic loading of agents is not allowed");
        }

        // 其余初始化操作...
    }
}

在上述示例中，premain办法是 Java 代理的入口点。通过调用 isDynamicAgentLoadingAllowed() 办法，能够查看是否容许动静加载代理。如果不容许，则抛出平安异样。

在应用动静加载代理禁用筹备之前，须要认真评估现有代码是否依赖于动静加载代理的性能。
须要更新相干的类加载器和平安管理器来反对禁止动静加载代理的性能。
应用动静加载代理禁用筹备时，须要确保应用程序的安全策略可能正确地管制动静加载代理的应用权限。

动静加载代理禁用筹备是一个 Java 加强提案，旨在禁止动静加载代理以进步应用程序的安全性。它通过批改类加载器、Instrumentation
API 和平安管理器来实现禁止动静加载代理的性能。只管这样做能够减少应用程序的安全性，但也可能影响依赖于动静加载代理的现有代码。因而，在应用该性能之前须要认真评估现有代码的依赖关系。

Key Encapsulation Mechanism (KEM) API 是一个 Java
API，用于反对密钥封装机制。密钥封装是一种加密技术，它将一个对称密钥（也称为会话密钥）与公钥联合应用，以便在不间接裸露私钥的状况下平安地传输密钥。

KEM API 提供了一组办法和类，用于生成、封装和解封装密钥。它能够与现有的密码学算法和协定集成，提供更高级别的密钥治理性能。

在传统的密钥替换过程中，通常须要当时共享或散发密钥。这可能存在许多平安危险，例如密钥泄露、中间人攻打等。而密钥封装机制通过应用公钥进行密钥替换，防止了这些问题。

Key Encapsulation Mechanism API 的呈现使得开发者可能更不便地实现密钥封装机制，并提供了更高级别的密钥治理性能。它简化了密钥生成、封装和解封装的过程，同时保障了安全性和可靠性。

Key Encapsulation Mechanism API 的实现原理基于非对称加密算法和密钥封装机制。它应用公钥进行密钥替换，并通过将会话密钥封装在一个平安的密文中，以确保密钥的平安传输。

具体实现过程如下：

生成一对公私钥对。
应用公钥进行密钥封装，生成一个密文。
将密文发送给接管方。
接管方应用私钥解封装密文，失去会话密钥。
单方能够应用会话密钥进行加密通信。

安全性高：Key Encapsulation Mechanism API 应用了非对称加密算法和密钥封装机制，可能提供较高的安全性，防止了密钥泄露和中间人攻打等问题。
易于应用：API 提供了简略易用的办法和类，开发者能够轻松地生成、封装和解封装密钥，无需深刻理解底层算法和协定。
灵活性强：API 能够与现有的密码学算法和协定集成，提供更高级别的密钥治理性能，满足不同场景的需要。

依赖于非对称加密算法：Key Encapsulation Mechanism API 的实现依赖于非对称加密算法，这些算法可能存在性能上的瓶颈和限度。
须要爱护私钥的平安：因为应用了非对称加密算法，私钥的平安至关重要。开发者须要采取措施来爱护私钥的机密性和完整性。

上面是一个简略的应用示例，演示了如何应用 Key Encapsulation Mechanism API 进行密钥封装和解封装：

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.KeyAgreement;
import javax.crypto.Cipher;

public class KEMExample {public static void main(String[] args) throws Exception {
        // 生成公私钥对
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        KeyPair keyPair = keyPairGenerator.generateKeyPair();

        // 创立 KeyAgreement 对象
        KeyAgreement keyAgreement = KeyAgreement.getInstance("DH");
        keyAgreement.init(keyPair.getPrivate());

        // 执行密钥协商过程
        keyAgreement.doPhase(keyPair.getPublic(), true);

        // 生成会话密钥
        byte[] sharedSecret = keyAgreement.generateSecret();

        // 封装会话密钥
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.WRAP_MODE, keyPair.getPublic());
        byte[] wrappedKey = cipher.wrap(sharedSecret);

        // 解封装会话密钥
        cipher.init(Cipher.UNWRAP_MODE, keyPair.getPrivate());
        byte[] unwrappedKey = cipher.unwrap(wrappedKey, "AES", Cipher.SECRET_KEY);

        // 输入后果
        System.out.println("Shared Secret:" + new String(sharedSecret));
        System.out.println("Unwrapped Key:" + new String(unwrappedKey));
    }
}

开发者须要抉择适合的非对称加密算法和密钥封装机制，依据具体需要进行配置。
私钥的平安至关重要，开发者应该采取措施来爱护私钥的机密性和完整性。
密钥封装过程中生成的密文须要通过平安信道传输，以确保密钥的安全性。

Key Encapsulation Mechanism API 是一个用于反对密钥封装机制的 Java
API。它提供了一组办法和类，用于生成、封装和解封装密钥。通过应用公钥进行密钥替换，防止了传统密钥替换形式中存在的平安危险。API
的实现原理基于非对称加密算法和密钥封装机制，可能提供较高的安全性和灵活性。开发者能够轻松地应用 API
进行密钥封装和解封装操作，并与现有的密码学算法和协定集成，满足不同场景的需要。然而，API 的应用须要留神私钥的安全性和密文的传输平安。

结构化并发是一种用于简化并发编程的 API。它将在不同线程中运行的相干工作组视为一个独自的工作单元，从而简化错误处理和勾销操作，进步可靠性，并加强可察看性。

传统的并发编程模型，如ExecutorService
API，因为其无限度的并发模式，引入了复杂性和危险。这些模型没有强制执行或跟踪工作和子工作之间的关系，使得治理和察看并发工作变得艰难。结构化并发模型认为工作构造应该反映代码构造，在单线程代码中，执行总是强制施行工作和子工作的层次结构，每个子工作的生命周期绝对于其余子工作受到代码的语法块构造的管制。

结构化并发旨在打消与并发编程相干的常见危险，例如线程透露和勾销提早，并加强并发代码的可察看性。

结构化并发通过引入新的 API 来实现，其中最重要的类是 StructuredTaskScope。StructuredTaskScope
封装了一组相干的工作，这些工作应该一起实现，如果任何子工作失败，则会勾销残余的子工作。

在结构化并发中，应用 StructuredTaskScope
创立一个作用域，在该作用域内能够派生出多个子工作。这些子工作将被视为整体，并且它们之间存在依赖关系。当所有子工作实现后，能够对它们进行解决，例如获取后果或抛出异样。

简化并发编程：结构化并发提供了一种更简略、更直观的形式来解决并发工作。
错误处理和勾销操作：通过将相干工作组合成一个单元，结构化并发使错误处理和勾销操作更加容易和牢靠。
进步可靠性：结构化并发模型打消了常见的危险，如线程透露和勾销提早，从而进步了并发代码的可靠性。
加强可察看性：结构化并发模型使得察看并发工作的执行状态变得更加不便。

预览性能：目前，结构化并发仍处于预览阶段，须要启用预览性能能力应用。

上面是一个应用结构化并发的示例代码：

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()
             .throwIfFailed();


        return new Response(user.get(), order.get());
    }

}

在这个示例中，咱们创立了一个新的 StructuredTaskScope 作用域，并应用它派生了两个子工作：一个执行 findUser()
办法，另一个执行 fetchOrder() 办法。一旦两个子工作都实现，就能够应用它们的后果创立一个新的 Response 对象。

结构化并发是一个预览性能，默认状况下被禁用。要应用StructuredTaskScope API，开发人员必须启用预览性能来编译代码。
应用结构化并发时，通常不间接应用 StructuredTaskScope
类，而是应用实现敞开策略的两个子类之一。这些子类别离是 ShutdownOnFailure 和ShutdownOnSuccess，反对当第一个子工作失败或胜利时敞开作用域的模式。
运行结构化并发程序时，须要应用 --enable-preview 选项启用预览性能。

结构化并发是一种用于简化并发编程的 API，它将相干工作组合成一个单元，从而简化错误处理和勾销操作，进步可靠性，并加强可察看性。通过引入 StructuredTaskScope
类和相干的子类，结构化并发提供了一种更简略、更直观的形式来解决并发工作。然而，须要留神的是，结构化并发目前仍处于预览阶段，并且须要启用预览性能能力应用。

JDK 21 将是大多数供应商的长期反对（LTS）版本。无关自上一个 LTS 版本 JDK 17 以来集成的 JEP
的残缺列表，请参阅 here.

| 2023/06/08 | | 第一阶段迟缓降级（从主分支派生）|

| 2023/07/20 | | 第二阶段迟缓降级 |

| 2023/08/10 | | 初始候选发行版 |

| 2023/08/24 | | 最终候选发行版 |

| 2023/09/19 | | 正式公布 |

最初更新工夫：2023 年 9 月 19 日 10:53 UTC

<!– md tj.md –>

本文由 mdnice 多平台公布

| 430: | String Templates (Preview) |

1. 什么是 String Templates?

2. 为什么须要 String Templates?

3. String Templates 的实现原理?

4. String Templates 的长处

5. String Templates 的毛病

6. String Templates 的应用示例

7. String Templates 的应用注意事项

8. 总结

| 431: | Sequenced Collections |

Sequenced Collections

1. 什么是 Sequenced Collections？

2. 为什么须要 Sequenced Collections？

3. Sequenced Collections 的实现原理

4. Sequenced Collections 的长处

5. Sequenced Collections 的毛病

6. Sequenced Collections 的应用示例

7. Sequenced Collections 的其余注意事项

8. 总结

| 439: | Generational ZGC |

1. 什么是 Generational ZGC?

2. 为什么须要 Generational ZGC?

3. Generational ZGC 的实现原理

年老代（Young Generation）

老年代（Old Generation）

并发解决

4. Generational ZGC 的长处

5. Generational ZGC 的毛病

6. Generational ZGC 的应用示例

7. Generational ZGC 的应用注意事项

8. 总结

| 440: | Record Patterns |

1. 什么是 Record Patterns?

2. 为什么须要 Record Patterns?

3. Record Patterns 的实现原理

记录类型

模式匹配

4. Record Patterns 的长处

5. Record Patterns 的毛病

6. Record Patterns 的应用示例

7. Record Patterns 的应用注意事项

8. 总结

| 441: | Pattern Matching for switch |

1. 什么是 Pattern Matching for switch?

2. 为什么须要 Pattern Matching for switch?

3. Pattern Matching for switch 的实现原理

模式匹配

类型推断

4. Pattern Matching for switch 的长处

5. Pattern Matching for switch 的毛病

6. Pattern Matching for switch 的应用示例

7. Pattern Matching for switch 的应用注意事项

8. 总结

| 442: | Foreign Function & Memory API (Third Preview) |

1. 什么是 Foreign Function & Memory API (Third Preview)?

2. 为什么须要 Foreign Function & Memory API?

3. Foreign Function & Memory API 的实现原理

4. Foreign Function & Memory API 的长处

5. Foreign Function & Memory API 的毛病

6. Foreign Function & Memory API 的应用示例

7. Foreign Function & Memory API 的应用注意事项

8. 总结

| 443: | Unnamed Patterns and Variables (Preview) |

1. 什么是 Unnamed Patterns and Variables (Preview)?

2. 为什么须要 Unnamed Patterns and Variables?

3. Unnamed Patterns and Variables 的实现原理

匿名模式

匿名变量

4. Unnamed Patterns and Variables 的长处

5. Unnamed Patterns and Variables 的毛病

6. Unnamed Patterns and Variables 的应用示例

7. Unnamed Patterns and Variables 的应用注意事项

8. 总结

| 444: | Virtual Threads |

1. 什么是 Virtual Threads?

2. 为什么须要 Virtual Threads?

3. Virtual Threads 的实现原理

4. Virtual Threads 的长处

5. Virtual Threads 的毛病

6. Virtual Threads 的应用示例