Java 21 新特性详细教程

Java 21 是 Java 的最新 长期支持版本（LTS），于 2023 年 9 月 发布。作为一个重要版本，Java 21 引入了多项语言增强和运行时改进，包含多个长期预览功能的正式发布（如虚拟线程），还推出了全新的功能（如字符串模板）。

1. 虚拟线程（Virtual Threads）

1.1 什么是虚拟线程？

虚拟线程是 Java 21 中正式发布的一项功能，旨在提供更轻量级的线程模型，可以在同一 JVM 上创建成千上万的线程。这是 Project Loom 的核心成果，用于解决传统线程的高开销问题。

1.2 特点

轻量级：虚拟线程不像传统线程绑定到操作系统线程，而是由 JVM 管理。
适合 I/O 密集型任务：例如处理高并发网络请求。
兼容性强：与现有的线程池和 API 完全兼容。

1.3 示例

传统线程：

public class TraditionalThreads {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> System.out.println("Hello from traditional thread")).start();
        }
    }
}

虚拟线程：

public class VirtualThreads {
    public static void main(String[] args) throws Exception {
        for (int i = 0; i < 10; i++) {
            Thread.ofVirtual().start(() -> System.out.println("Hello from virtual thread"));
        }
    }
}

线程池中使用虚拟线程：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class VirtualThreadExecutor {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();

        for (int i = 0; i < 10; i++) {
            executor.submit(() -> {
                System.out.println("Running task in virtual thread");
            });
        }

        executor.close();
    }
}

输出：

Hello from virtual thread
Running task in virtual thread
...

1.4 优势

可以创建数百万线程，极大提升并发处理能力。
性能更高，资源占用更低。
简化了线程模型的使用，避免复杂的线程池管理。

2. 字符串模板（String Templates）

2.1 什么是字符串模板？

字符串模板提供了一种全新的字符串拼接方式，通过内嵌表达式动态生成字符串，类似于许多现代语言的模板字符串（如 JavaScript 的模板字符串）。

2.2 语法

使用反引号（`）定义字符串模板。
表达式放在 ${} 中。

2.3 示例

基础用法：

public class StringTemplates {
    public static void main(String[] args) {
        String name = "Java";
        int version = 21;
        System.out.println(`Welcome to ${name} ${version}!`);
    }
}

输出：

Welcome to Java 21!

多行模板：

public class MultiLineTemplate {
    public static void main(String[] args) {
        String title = "Features";
        System.out.println(`
            Welcome to Java 21!
            New ${title} include:
                - Virtual Threads
                - String Templates
        `);
    }
}

输出：

Welcome to Java 21!
New Features include:
    - Virtual Threads
    - String Templates

2.4 优势

更直观地构建动态字符串。
提高代码可读性，减少拼接错误。
支持多行字符串处理。

3. 模式匹配增强（Pattern Matching）

3.1 什么是模式匹配？

模式匹配通过 instanceof 和 switch 的增强，允许根据对象的类型或属性执行不同的操作。

3.2 示例

传统代码：

if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.toUpperCase());
}

模式匹配的代码：

if (obj instanceof String s) {
    System.out.println(s.toUpperCase());
}

Switch 中的模式匹配：

public class PatternMatchingSwitch {
    public static void main(String[] args) {
        Object obj = 42;

        String result = switch (obj) {
            case Integer i -> "Integer: " + i;
            case String s -> "String: " + s;
            default -> "Unknown type";
        };

        System.out.println(result);
    }
}

4. 记录模式（Record Patterns）

4.1 什么是记录模式？

记录模式扩展了模式匹配的功能，允许在 switch 或 if 中解构 record 类型对象。

4.2 示例

public record Point(int x, int y) {}

public class RecordPattern {
    public static void main(String[] args) {
        Point point = new Point(3, 5);

        String result = switch (point) {
            case Point(int x, int y) -> "Point with x: " + x + " and y: " + y;
        };

        System.out.println(result);
    }
}

输出：

Point with x: 3 and y: 5

5. 结构化并发（Structured Concurrency）

5.1 什么是结构化并发？

结构化并发提供了一种更简单、更安全的并发编程方式，简化了多任务协作。

5.2 示例

import java.util.concurrent.*;

public class StructuredConcurrency {
    public static void main(String[] args) throws Exception {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            Future<String> user = scope.fork(() -> fetchUser());
            Future<Integer> order = scope.fork(() -> fetchOrder());

            scope.join();
            scope.throwIfFailed();

            System.out.println("User: " + user.resultNow());
            System.out.println("Order: " + order.resultNow());
        }
    }

    static String fetchUser() throws InterruptedException {
        Thread.sleep(500);
        return "User123";
    }

    static int fetchOrder() throws InterruptedException {
        Thread.sleep(500);
        return 42;
    }
}

6. 新的线程操作 API

Java 21 中对线程的操作 API 进行了增强，例如：超时的 join 和 sleep 方法。

示例

Thread thread = new Thread(() -> {
    try {
        Thread.sleep(Duration.ofSeconds(2));
        System.out.println("Thread finished");
    } catch (InterruptedException e) {
        System.out.println("Thread interrupted");
    }
});

thread.start();
thread.join(Duration.ofSeconds(1)); // 超时 join

7. 垃圾回收改进（GC Enhancements）

G1 GC 和 ZGC：优化了性能，进一步降低了延迟。
Shenandoah GC：支持大规模堆，暂停时间更短。

8. 其他新增和改进

String 的 stripIndent 和 translateEscapes 方法：
- stripIndent：移除多行字符串的公共缩进。
- translateEscapes：将转义字符转换为实际字符。
向量 API：
- 提供了硬件加速的向量计算支持，用于机器学习等高性能计算场景。
Foreign Function & Memory API（FFM API）：
- 提供更安全和高效的外部函数调用与内存访问。

9. 总结

Java 21 是一个功能丰富且现代化的版本，长期支持（LTS）意味着它适合生产环境的广泛应用。通过虚拟线程、字符串模板、结构化并发和模式匹配等功能，Java 开发变得更加高效和灵活。

Java8 新特性
 Java11 新特性
 Java17 新特性
 Java21 新特性