Some Notes

Java 19 和 20 主要⁢是为一些重大特性做准⁡备，包括虚拟线程、R⁡ecord 模式、Switch 模式匹配等。

Java 19 新特性（2022年9月）

正式特性

【了解】Linux/RISC-V 端口

Java 19 正式支持 RISC-⁢V 架构的 Linux ⁡系统： ⁡

bash

# 在 RISC-V 系统上运行 Java
java -version
# 输出会显示 riscv64 架构信息

# RISC-V 是一个开源的指令集架构
# 主要用于嵌入式设备和服务器

RISC-V 的特点：

开源免费：不需要授权费用
可扩展性：支持自定义指令
生态发展：越来越多厂商支持

预览特性

【了解】虚拟线程（预览）

Java 19 引入了虚拟线⁢程作为预览特性，这⁡是 Project⁡ Loom 的核心成果：

java

// 需要启用预览功能
// javac --enable-preview --release 19 VirtualThreadExample.java
// java --enable-preview VirtualThreadExample

public class VirtualThreadExample {
    public static void main(String[] args) throws InterruptedException {
        // 创建虚拟线程
        Thread vThread = Thread.ofVirtual().start(() -> {
            System.out.println("虚拟线程运行中: " + Thread.currentThread());
        });
        vThread.join();
        
        // 使用虚拟线程执行器
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            // 创建大量虚拟线程
            for (int i = 0; i < 100000; i++) {
                final int taskId = i;
                executor.submit(() -> {
                    try {
                        Thread.sleep(1000); // 模拟 I/O 操作
                        System.out.println("任务 " + taskId + " 完成");
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                });
            }
        } // 自动关闭执行器
    }
}

虚拟线程的特点：

轻量级：一个虚拟线程只占用几 KB 内存
高并发：可以创建百万级别的虚拟线程
简单编程模型：使用传统的同步编程风格

【了解】Record 模式（预览）

Java 19 引入了 Record 模式匹配：

java

// 定义 Records
public record Point(int x, int y) {}
public record Person(String name, int age) {}

public class RecordPatternExample {
    public static void main(String[] args) {
        Object obj = new Point(3, 4);
        
        // Record 模式匹配
        if (obj instanceof Point(var x, var y)) {
            System.out.println("点的坐标: (" + x + ", " + y + ")");
            System.out.println("距离原点: " + Math.sqrt(x * x + y * y));
        }
        
        // 嵌套的 Record 模式
        record Address(String city, String street) {}
        record Employee(Person person, Address address) {}
        
        Employee emp = new Employee(
            new Person("张三", 30),
            new Address("北京", "中关村大街")
        );
        
        // 嵌套解构
        if (emp instanceof Employee(Person(var name, var age), Address(var city, var street))) {
            System.out.println(name + "，" + age + "岁，住在" + city + street);
        }
    }
}

【了解】switch 的模式匹配（第三次预览）

Java 19 继续完善 switch 模式匹配：

java

public String processValue(Object value) {
    return switch (value) {
        case String s -> "字符串: " + s;
        case Integer i -> "整数: " + i;
        case Point(var x, var y) -> "点: (" + x + ", " + y + ")";
        case null -> "空值";
        default -> "其他类型";
    };
}

// 结合条件判断
public String analyzePoint(Object obj) {
    return switch (obj) {
        case Point(var x, var y) when x == 0 && y == 0 -> "原点";
        case Point(var x, var y) when x == 0 -> "Y轴上的点";
        case Point(var x, var y) when y == 0 -> "X轴上的点";
        case Point(var x, var y) -> "普通点: (" + x + ", " + y + ")";
        case null -> "空值";
        default -> "不是点";
    };
}

【了解】外部函数和内存 API（预览）

Java 19 将外部函数和内存 API 升级为预览特性：

java

import java.lang.foreign.*;

public class ForeignAPIExample {
    public static void main(String[] args) throws Throwable {
        // 获取 C 标准库链接器
        Linker linker = Linker.nativeLinker();
        SymbolLookup stdlib = linker.defaultLookup();
        
        // 查找 strlen 函数
        MemoryAddress strlen = stdlib.find("strlen").orElseThrow();
        
        // 创建函数描述符
        FunctionDescriptor descriptor = FunctionDescriptor.of(
            ValueLayout.JAVA_LONG,      // 返回类型
            ValueLayout.ADDRESS         // 参数类型
        );
        
        // 创建方法句柄
        MethodHandle strlenHandle = linker.downcallHandle(strlen, descriptor);
        
        // 分配内存并调用
        try (Arena arena = Arena.ofConfined()) {
            MemorySegment cString = arena.allocateUtf8String("Hello Foreign API!");
            long length = (long) strlenHandle.invoke(cString);
            System.out.println("字符串长度: " + length);
        }
    }
}

孵化器特性

【了解】向量 API（第四次孵化器）

Java 19 继续改进向量⁢ API： ⁡ ⁡

java

import jdk.incubator.vector.*;

public class VectorExample {
    private static final VectorSpecies<Integer> SPECIES = IntVector.SPECIES_PREFERRED;
    
    public static void vectorizedSum(int[] a, int[] b, int[] result) {
        int upperBound = SPECIES.loopBound(a.length);
        
        // 向量化循环
        for (int i = 0; i < upperBound; i += SPECIES.length()) {
            IntVector va = IntVector.fromArray(SPECIES, a, i);
            IntVector vb = IntVector.fromArray(SPECIES, b, i);
            IntVector vr = va.add(vb);
            vr.intoArray(result, i);
        }
        
        // 处理剩余元素
        for (int i = upperBound; i < a.length; i++) {
            result[i] = a[i] + b[i];
        }
    }
    
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 5, 6, 7, 8};
        int[] b = {8, 7, 6, 5, 4, 3, 2, 1};
        int[] result = new int[8];
        
        vectorizedSum(a, b, result);
        System.out.println(Arrays.toString(result));
        // [9, 9, 9, 9, 9, 9, 9, 9]
    }
}

【了解】结构化并发（孵化器）

Java 19 引入了结构化并发 API：

java

import jdk.incubator.concurrent.StructuredTaskScope;

public class StructuredConcurrencyExample {
    public static void main(String[] args) {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            // 并发执行多个任务
            var task1 = scope.fork(() -> fetchUserData(1));
            var task2 = scope.fork(() -> fetchUserPreferences(1));
            var task3 = scope.fork(() -> fetchUserHistory(1));
            
            // 等待所有任务完成或任一失败
            scope.join();
            scope.throwIfFailed();
            
            // 获取结果
            UserData userData = task1.resultNow();
            UserPreferences prefs = task2.resultNow();
            UserHistory history = task3.resultNow();
            
            System.out.println("用户数据加载完成");
            
        } catch (Exception e) {
            System.err.println("加载用户数据失败: " + e.getMessage());
        }
    }
    
    private static UserData fetchUserData(int userId) {
        // 模拟网络请求
        try { Thread.sleep(100); } catch (InterruptedException e) {}
        return new UserData("张三", "zhangsan@example.com");
    }
    
    private static UserPreferences fetchUserPreferences(int userId) {
        try { Thread.sleep(150); } catch (InterruptedException e) {}
        return new UserPreferences("dark", "zh-CN");
    }
    
    private static UserHistory fetchUserHistory(int userId) {
        try { Thread.sleep(200); } catch (InterruptedException e) {}
        return new UserHistory(List.of("登录", "查看文档", "退出"));
    }
}

record UserData(String name, String email) {}
record UserPreferences(String theme, String language) {}
record UserHistory(List<String> actions) {}

Java 20 新特性（2023年3月）

Java 20 主要是继续完⁢善预览特性，没有引⁡入新的正式特性。

预览特性

【了解】Record 模式（第二次预览）

Java 20 继续完善 Record 模式：

java

public class RecordPatternExample {
    // 定义复杂的 Record 层次
    public sealed interface Shape permits Circle, Rectangle {}
    public record Circle(double radius) implements Shape {}
    public record Rectangle(double width, double height) implements Shape {}
    
    public record ColoredShape(Shape shape, String color) {}
    
    public static void main(String[] args) {
        ColoredShape redCircle = new ColoredShape(new Circle(5.0), "红色");
        
        // 嵌套 Record 模式匹配
        switch (redCircle) {
            case ColoredShape(Circle(var radius), var color) -> 
                System.out.println(color + "圆形，半径：" + radius);
            case ColoredShape(Rectangle(var width, var height), var color) -> 
                System.out.println(color + "矩形，" + width + "x" + height);
        }
        
        // 在 if 语句中使用
        if (redCircle instanceof ColoredShape(Circle(var r), var c) && r > 3) {
            System.out.println("大" + c + "圆形");
        }
    }
}

【了解】switch 的模式匹配（第四次预览）

Java 20 进一步改进了 switch 模式匹配：

java

public class SwitchPatternExample {
    public static String analyzeValue(Object value) {
        return switch (value) {
            case null -> "空值";
            case String s when s.isEmpty() -> "空字符串";
            case String s when s.length() == 1 -> "单字符: " + s;
            case String s -> "字符串: " + s + " (长度: " + s.length() + ")";
            case Integer i when i == 0 -> "零";
            case Integer i when i > 0 -> "正整数: " + i;
            case Integer i -> "负整数: " + i;
            case Point(var x, var y) when x == y -> "对角线上的点: (" + x + ", " + y + ")";
            case Point(var x, var y) -> "点: (" + x + ", " + y + ")";
            default -> "未知类型: " + value.getClass().getSimpleName();
        };
    }
    
    // 处理集合
    public static String analyzeList(Object obj) {
        return switch (obj) {
            case null -> "空引用";
            case List<?> list when list.isEmpty() -> "空列表";
            case List<?> list when list.size() == 1 -> "单元素列表: " + list.get(0);
            case List<?> list -> "列表，大小: " + list.size();
            default -> "不是列表";
        };
    }
}

【了解】外部函数和内存 API（第二次预览）

Java 20 继续完善外部函数和内存 API：

java

import java.lang.foreign.*;

public class AdvancedForeignExample {
    public static void main(String[] args) throws Throwable {
        Linker linker = Linker.nativeLinker();
        SymbolLookup stdlib = linker.defaultLookup();
        
        // 调用 qsort 函数进行排序
        MemoryAddress qsort = stdlib.find("qsort").orElseThrow();
        FunctionDescriptor qsortDesc = FunctionDescriptor.ofVoid(
            ValueLayout.ADDRESS,    // 数组指针
            ValueLayout.JAVA_LONG,  // 元素数量
            ValueLayout.JAVA_LONG,  // 元素大小
            ValueLayout.ADDRESS     // 比较函数指针
        );
        MethodHandle qsortHandle = linker.downcallHandle(qsort, qsortDesc);
        
        // 创建比较函数
        FunctionDescriptor compareDesc = FunctionDescriptor.of(
            ValueLayout.JAVA_INT,
            ValueLayout.ADDRESS,
            ValueLayout.ADDRESS
        );
        MethodHandle compareFunction = MethodHandles.lookup()
            .findStatic(AdvancedForeignExample.class, "compareInts", 
                       MethodType.methodType(int.class, MemorySegment.class, MemorySegment.class));
        
        MemorySegment compareStub = linker.upcallStub(compareFunction, compareDesc, Arena.global());
        
        // 创建要排序的数组
        try (Arena arena = Arena.ofConfined()) {
            int[] javaArray = {64, 34, 25, 12, 22, 11, 90};
            MemorySegment nativeArray = arena.allocateArray(ValueLayout.JAVA_INT, javaArray);
            
            // 调用 qsort
            qsortHandle.invoke(nativeArray, (long)javaArray.length, 
                             ValueLayout.JAVA_INT.byteSize(), compareStub);
            
            // 读取排序后的结果
            int[] sorted = nativeArray.toArray(ValueLayout.JAVA_INT);
            System.out.println("排序结果: " + Arrays.toString(sorted));
        }
    }
    
    public static int compareInts(MemorySegment a, MemorySegment b) {
        int valueA = a.get(ValueLayout.JAVA_INT, 0);
        int valueB = b.get(ValueLayout.JAVA_INT, 0);
        return Integer.compare(valueA, valueB);
    }
}

【了解】虚拟线程（第二次预览）

Java 20 改进了虚拟线程：

java

public class VirtualThreadExample {
    public static void main(String[] args) throws InterruptedException {
        // 使用 Thread.Builder 创建虚拟线程
        Thread.Builder builder = Thread.ofVirtual().name("worker-", 0);
        
        List<Thread> threads = new ArrayList<>();
        
        // 创建大量虚拟线程
        for (int i = 0; i < 1000000; i++) {
            final int taskId = i;
            Thread thread = builder.start(() -> {
                try {
                    // 模拟 I/O 密集型任务
                    Thread.sleep(Duration.ofMillis(100));
                    if (taskId % 100000 == 0) {
                        System.out.println("任务 " + taskId + " 完成，线程: " + Thread.currentThread());
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
            
            if (i < 10) { // 只保留前10个线程的引用用于演示
                threads.add(thread);
            }
        }
        
        // 等待部分线程完成
        for (Thread thread : threads) {
            thread.join();
        }
        
        System.out.println("虚拟线程演示完成");
    }
}

孵化器特性

【了解】作用域值（孵化器）

Java 20 引入了作用域值 API：

java

import jdk.incubator.concurrent.ScopedValue;

public class ScopedValueExample {
    // 定义作用域值
    private static final ScopedValue<String> USER_ID = ScopedValue.newInstance();
    private static final ScopedValue<String> REQUEST_ID = ScopedValue.newInstance();
    
    public static void main(String[] args) {
        // 绑定作用域值
        ScopedValue.where(USER_ID, "user123")
                   .where(REQUEST_ID, "req456")
                   .run(() -> {
                       processRequest();
                   });
    }
    
    private static void processRequest() {
        System.out.println("处理请求，用户ID: " + USER_ID.get());
        System.out.println("请求ID: " + REQUEST_ID.get());
        
        // 调用其他方法，作用域值自动传递
        callService();
    }
    
    private static void callService() {
        // 在任何地方都可以访问作用域值
        System.out.println("服务调用，用户ID: " + USER_ID.get());
        System.out.println("请求ID: " + REQUEST_ID.get());
    }
}

作用域值的优势： ⁢ ⁡ ⁡

不可变性：一旦绑定就不能修改
自动传递：在调用链中自动传递
性能优化：比 ThreadLocal 更高效
结构化：有明确的作用域边界

【了解】结构化并发（第二次孵化器）

Java 20 改进了结构化并发：

java

import jdk.incubator.concurrent.StructuredTaskScope;

public class StructuredConcurrencyExample {
    public static void main(String[] args) {
        String result = fetchUserProfile(123);
        System.out.println(result);
    }
    
    public static String fetchUserProfile(int userId) {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            // 并发获取用户信息
            var userTask = scope.fork(() -> fetchUser(userId));
            var profileTask = scope.fork(() -> fetchProfile(userId));
            var settingsTask = scope.fork(() -> fetchSettings(userId));
            
            // 等待所有任务完成
            scope.join();
            scope.throwIfFailed();
            
            // 组合结果
            User user = userTask.resultNow();
            Profile profile = profileTask.resultNow();
            Settings settings = settingsTask.resultNow();
            
            return String.format("用户: %s, 个人资料: %s, 设置: %s", 
                               user, profile, settings);
                               
        } catch (Exception e) {
            return "获取用户信息失败: " + e.getMessage();
        }
    }
    
    private static User fetchUser(int userId) {
        // 模拟数据库查询
        simulateDelay(100);
        return new User("user" + userId, "user" + userId + "@example.com");
    }
    
    private static Profile fetchProfile(int userId) {
        simulateDelay(150);
        return new Profile("个人简介", "北京");
    }
    
    private static Settings fetchSettings(int userId) {
        simulateDelay(80);
        return new Settings("dark", "zh-CN");
    }
    
    private static void simulateDelay(int millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

record User(String name, String email) {}
record Profile(String bio, String location) {}
record Settings(String theme, String language) {}

总结

Java 19 和 20 是为重大特性做⁢准备的版本，虚拟线程、Re⁡cord 模式匹配、结构化⁡并发等特性虽然还处于预览阶段，但已经展现出巨大的潜力。

虚拟线程将彻底改变 Java 的并发编程模式，让开发者⁢可以用同步的方式编写高并发代码。Re⁡cord 模式匹配和 switch ⁡模式匹配让数据处理更加优雅。结构化并发为复杂的异步编程提供了更好的抽象。m3PjpOn2ZLs8GZn77OyloNG2CJecWXyKy5qfyUBLUZ8=

这些特性在 Java 21 ⁢中得到了正式化，成⁡为现代 Java ⁡开发的重要组成部分。

Java 19 新特性（2022年9月） ​

正式特性 ​

【了解】Linux/RISC-V 端口 ​

预览特性 ​

【了解】虚拟线程（预览） ​

【了解】Record 模式（预览） ​

【了解】switch 的模式匹配（第三次预览） ​

【了解】外部函数和内存 API（预览） ​

孵化器特性 ​

【了解】向量 API（第四次孵化器） ​

【了解】结构化并发（孵化器） ​

Java 20 新特性（2023年3月） ​

预览特性 ​

【了解】Record 模式（第二次预览） ​

【了解】switch 的模式匹配（第四次预览） ​

【了解】外部函数和内存 API（第二次预览） ​

【了解】虚拟线程（第二次预览） ​

孵化器特性 ​

【了解】作用域值（孵化器） ​

【了解】结构化并发（第二次孵化器） ​

总结 ​

Java 19 新特性（2022年9月）

正式特性

【了解】Linux/RISC-V 端口

预览特性

【了解】虚拟线程（预览）

【了解】Record 模式（预览）

【了解】switch 的模式匹配（第三次预览）

【了解】外部函数和内存 API（预览）

孵化器特性

【了解】向量 API（第四次孵化器）

【了解】结构化并发（孵化器）

Java 20 新特性（2023年3月）

预览特性

【了解】Record 模式（第二次预览）

【了解】switch 的模式匹配（第四次预览）

【了解】外部函数和内存 API（第二次预览）

【了解】虚拟线程（第二次预览）

孵化器特性

【了解】作用域值（孵化器）

【了解】结构化并发（第二次孵化器）

总结