嗨，朋友，你还在用Java 8 吗？Java 23 正式发布了~

引言

9月19日消息，Java 23目前已经正式推出，这是继Java 22之后的又一个非长期支持（LTS）版本，Oracle 对此版本仅提供六个月的支持。 Java 23包含12个新的JEP（JDK增强提案），其中包括其中包括将ZGC的默认模式切换为分代模式。

此版本包含 12 个 JEP，其中包括将 ZGC 的默认模式切换为分代模式。

455：模式中的原始类型、instanceof 和 switch（Preview）
466：Class-File API（Second Preview）
467：Markdown 文档注释
469：Vector API（Eighth Incubator）
473：Stream Gatherers（Second Preview）
471：弃用 sun.misc.Unsafe 中的内存访问方法并删除
474：ZGC：默认的分代模式
476：模块导入声明（Preview）
477：隐式声明的类和实例主方法（Third Preview）
480：结构化并发（Third Preview）
481：范围值（Third Preview）
482：灵活的构造函数主体（Third Preview）

此版本还包含很多较小的增强功能和错误修复。

下载地址：https://jdk.java.net/23/
发行说明：https://jdk.java.net/23/release-notes
发版履历：https://www.oracle.com/news/announcement/oracle-releases-java-23-2024-09-17/

---

特性和改进

Java 23 (JDK 23) 已于 2024 年 9 月正式发布，这是 Java 开发中的一个重要版本，带来了许多新的特性和改进。

1. **虚拟线程（Virtual Threads）改进：**虚拟线程是 Java 的 Project Loom 的核心特性，进一步简化并发编程。这一版本继续优化虚拟线程的性能，减少上下文切换开销，使得处理大量并发任务更加轻松。

2. **记录模式（Record Patterns）正式版：**Java 23 推出了记录模式，允许在模式匹配中解构记录对象，使得代码更简洁和表达能力更强。记录模式进一步增强了模式匹配的灵活性。

3. **字符串模板（String Templates）：**Java 23 引入了字符串模板，这是一种改进的字符串拼接机制，允许更灵活的格式化操作，类似于其他语言中的字符串插值。

4. **垃圾回收器（Garbage Collector, GC）改进：**Java 23 对垃圾回收器进行了一些优化，尤其是 ZGC（Z Garbage Collector），进一步减少了内存占用和暂停时间，提升了应用程序在大规模内存场景下的性能。

5. **性能改进：**Java 23 继续在性能上进行优化，包括即时编译器（JIT）的提升和更高效的类加载机制。尤其是对于大规模应用和云环境的支持，Java 23 增强了吞吐量和资源利用效率。

6. **更多封装与模块化：**模块化系统得到了进一步改进，增强了对大型项目的支持。Java 23 加强了对访问控制的封装，减少了模块之间的耦合性，提升了代码的健壮性。

7. **项目 Valhalla 预览特性：**项目 Valhalla 的一些关键特性，如值类型（Value Types），在 Java 23 中进入了预览阶段。这些特性将改变 Java 对象模型的处理方式，使得原始类型和对象的表现更加一致。

8. **反射与代理机制优化：**Java 23 对反射和代理的性能做出了重要优化，使得这些功能在大规模使用时更加高效，适合高性能场景。

---

Java 8 VS. Java 23

为了更好地理解 Java 23 中的新特性和改进，以下是每个特性与 Java 8 的对比。这些对比会帮助大家了解 Java 23 提供的改进，并展示为什么它更具优势。

虚拟线程（Virtual Threads） vs. Java 8 的传统线程

Java 8 传统线程

Java 8 使用操作系统线程来处理并发任务，创建和切换线程的成本相对较高，因此在高并发场景下效率较低。

public class Java8Threads {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                System.out.println("Running on thread " + Thread.currentThread());
            });
            thread.start();
        }
    }
}

Java 23 虚拟线程

虚拟线程是用户态线程，创建和调度的成本极低，适合大规模并发。

public class Java23VirtualThreads {
    public static void main(String[] args) throws InterruptedException {
        try (var executor = java.util.concurrent.Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 10; i++) {
                executor.submit(() -> {
                    System.out.println("Running on virtual thread " + Thread.currentThread());
                });
            }
        }
    }
}

• Java 8 的传统线程由于成本较高，不适合处理大量并发任务。
• Java 23 的虚拟线程非常轻量，适合处理成千上万个并发任务，内存占用更低。

---

记录模式（Record Patterns） vs. Java 8 的传统对象模式匹配

Java 8 没有模式匹配功能，开发者需要使用手动的 instanceof 和类型转换。

public class Java8PatternMatching {
    static class Person {
        String name;
        int age;

        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    }

    public static void main(String[] args) {
        Object obj = new Person("Alice", 30);
        if (obj instanceof Person) {
            Person person = (Person) obj;
            System.out.println(person.name + " is " + person.age + " years old.");
        }
    }
}

Java 23 支持记录模式，简化了对象解构和匹配。

record Person(String name, int age) {}

public class Java23RecordPatterns {
    public static void main(String[] args) {
        Object obj = new Person("Alice", 30);
        if (obj instanceof Person(String name, int age)) {
            System.out.println(name + " is " + age + " years old.");
        }
    }
}

• Java 8 手动 instanceof 和类型转换繁琐。
• Java 23 通过模式匹配可以直接解构对象，代码更加简洁。

---

字符串模板（String Templates） vs. Java 8 的字符串拼接

Java 8 的字符串拼接通常使用 + 操作符或 String.format()，但这样显得不够直观，尤其是拼接复杂的字符串时。

public class Java8StringTemplates {
    public static void main(String[] args) {
        String name = "Alice";
        int age = 30;
        String message = String.format("Hello, %s, you are %d years old.", name, age);
        System.out.println(message);
    }
}

Java 23 引入了字符串模板，使字符串插值变得简单易读。

public class Java23StringTemplates {
    public static void main(String[] args) {
        String name = "Alice";
        int age = 30;
        String message = STR."Hello, \{name}, you are \{age} years old.";
        System.out.println(message);
    }
}

• Java 8 的字符串拼接冗长，尤其是在嵌入复杂逻辑时。
• Java 23 的字符串模板简洁且直观，类似于其他现代编程语言的插值语法。

---

垃圾回收器（Garbage Collector, GC） vs. Java 8 的 GC

Java 8 默认使用的是 Parallel GC 或 CMS（Concurrent Mark-Sweep）。虽然 CMS 提供了较低的暂停时间，但垃圾回收的效率有限。

启用 CMS GC：

java -XX:+UseConcMarkSweepGC MyApplication

Java 23 的 ZGC（Z Garbage Collector）专注于超低暂停时间，特别适用于大内存、高并发应用程序。

启用 ZGC：

java -XX:+UseZGC MyApplication

• Java 8 的 GC 在高并发、大内存场景下会产生较长的暂停时间。
• Java 23 的 ZGC 几乎不会影响应用程序的响应时间，提升了大规模应用的稳定性。

---

性能改进 vs. Java 8

Java 8 的类加载和即时编译器（JIT）没有经过现代优化，在高并发或复杂计算任务中表现相对不够出色。

public class Java8Performance {
    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> {
                long sum = 0;
                for (int j = 0; j < 1000000; j++) {
                    sum += j;
                }
                System.out.println("Sum: " + sum);
            }).start();
        }
    }
}

Java 23 对类加载和 JIT 编译器进行了多项优化，提升了并发处理性能和吞吐量。

public class Java23Performance {
    public static void main(String[] args) throws InterruptedException {
        try (var executor = java.util.concurrent.Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 1000; i++) {
                executor.submit(() -> {
                    long sum = 0;
                    for (int j = 0; j < 1000000; j++) {
                        sum += j;
                    }
                    System.out.println("Sum: " + sum);
                });
            }
        }
    }
}

• Java 8 在大量并发场景下性能受限，线程创建和切换的开销较高。
• Java 23 的虚拟线程结合 JIT 优化，能有效提升并发性能和资源利用率。

---

更多封装与模块化 vs. Java 8

Java 8 没有内置的模块系统，所有代码都处于同一个类路径下，容易引起类冲突和访问不当。

package com.myapp.services;

public class Service {
    public void performTask() {
        System.out.println("Performing task...");
    }
}

Java 23 增强了模块化系统，通过 module-info.java 实现更强的封装和访问控制。

module my.module {
    exports com.myapp.services;
}

• Java 8 没有模块化，代码容易耦合和依赖不当。
• Java 23 的模块系统强制模块封装，减少了潜在的依赖问题，适合大型应用。

---

项目 Valhalla 的值类型（Value Types） vs. Java 8 的对象模型

Java 8 的对象都是引用类型，无法避免内存堆分配和垃圾回收的开销。

public class Java8Objects {
    static class Point {
        int x;
        int y;

        Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    public static void main(String[] args) {
        Point p1 = new Point(10, 20);
        Point p2 = new Point(10, 20);
        System.out.println(p1 == p2);  // 输出 false，因为是不同的对象引用
    }
}

Java 23 中的值类型在内存管理上更高效，避免了对象的引用模型。

__ByValue final class Point {
    int x;
    int y;
}

public class ValhallaExample {
    public static void main(String[] args) {
        Point p1 = new Point(10,20);
        Point p2 = new Point(10, 20);
        System.out.println(p1 == p2);  // 输出 true，因为值类型按值比较
    }
}

• Java 8 只能使用引用类型，比较时需要考虑内存地址。
• Java 23 值类型能避免额外的内存开销，提高内存布局效率。

---

反射与代理机制优化 vs. Java 8 的反射

Java 23 的反射和代理机制的改进主要体现在 底层性能 和 效率优化，而不是 API 或 语法 的变化。这意味着从开发者角度来看，使用反射和代理的代码写法并没有大的调整，依旧保持着类似的调用方式和风格。

Java 8 提供了通过 java.lang.reflect.Proxy 创建动态代理的机制，允许在运行时拦截接口方法的调用并进行自定义逻辑处理。以下是 Java 8 的反射和代理的典型用法：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Java8DynamicProxy {
    interface MyInterface {
        void doSomething();
    }

    static class MyHandler implements InvocationHandler {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("Before method: " + method.getName());
            // 动态代理的核心：在此执行代理逻辑
            Object result = null;  // 调用目标方法或自定义逻辑
            System.out.println("After method: " + method.getName());
            return result;
        }
    }

    public static void main(String[] args) {
        // 使用 Proxy 创建动态代理对象
        MyInterface proxyInstance = (MyInterface) Proxy.newProxyInstance(
            MyInterface.class.getClassLoader(),
            new Class[] { MyInterface.class },
            new MyHandler()
        );

        // 调用代理方法
        proxyInstance.doSomething();  // 输出 Before method: doSomething 和 After method: doSomething
    }
}

Java 23 通过多项优化（如对 MethodHandle、ReflectionFactory 等底层机制的优化），大幅减少了反射和代理机制的开销。Java 23 动态代理的优化，能提升代理对象的调用效率，减少内存分配和访问延迟。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Java23DynamicProxy {
    interface MyInterface {
        void doSomething();
    }

    static class MyHandler implements InvocationHandler {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("Before method: " + method.getName());
            // 这里可以是更优化的代理逻辑
            Object result = null;  // 可以实际调用目标方法
            System.out.println("After method: " + method.getName());
            return result;
        }
    }

    public static void main(String[] args) {
        MyInterface proxyInstance = (MyInterface) Proxy.newProxyInstance(
            MyInterface.class.getClassLoader(),
            new Class[] { MyInterface.class },
            new MyHandler()
        );

        proxyInstance.doSomething();  // 和 Java 8 类似的输出

        // 优化后的代理机制，可以在复杂场景中显著减少性能开销
    }
}

在高并发、高性能要求的应用场景下，Java 23 的反射和代理机制大大提升了性能，减少了内存使用，并优化了代理对象的创建速度。

特性	Java 8	Java 23
动态代理性能	性能较低，频繁调用时可能会引发性能问题	性能优化，通过 MethodHandle 提高了执行效率
反射调用开销	使用 Method.invoke()，调用较慢	使用 MethodHandle 或 VarHandle，性能更高
内存管理	创建代理对象时会增加内存占用	动态代理机制进行了内存优化，减少了内存开销
使用场景	适合简单场景，复杂和高并发场景下性能不足	适合复杂场景和高并发应用，性能和稳定性大幅提高
底层实现优化	基于传统的 Reflection 实现	底层进行了字节码生成和方法调用机制的优化

Java 8 Method.invoke() 底层实现（简化版）

Java 8 的 Method.invoke() 机制相对较为笨重，主要涉及以下步骤：

• 安全检查：每次反射调用时，JVM 都会进行权限检查，确保调用方具有访问目标方法的权限。
• 类型检查和转换：在调用目标方法之前，JVM 需要将传入的参数从 Object 转换为目标方法的参数类型。
• 方法查找：反射调用需要查找并验证目标方法的实现。
• 方法执行：最终执行方法调用并处理返回值。

public Object invoke(Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    // 1. 权限检查
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Reflection.ensureMemberAccess(Reflection.getCallerClass(), clazz, obj, modifiers);
        }
    }
    // 2. 检查和转换参数
    MethodAccessor ma = methodAccessor; 
    if (ma == null) {  // 使用缓存
        ma = acquireMethodAccessor();
    }
    // 3. 调用方法
    return ma.invoke(obj, args);
}

Java 23 MethodHandle 的底层实现（简化版）

MethodHandle 的调用直接依赖于 JVM 的优化路径，绕过了 Method.invoke() 的冗余过程。

• 无安全检查：MethodHandle 依赖 MethodHandles.Lookup 进行权限控制，只需要在查找阶段进行一次权限检查，后续的调用不再进行检查。
• 无参数类型转换：在调用阶段，MethodHandle 可以直接传递强类型的参数，减少了 Object 参数的拆装箱操作。
• 无反射查找：MethodHandle 在第一次查找时完成了所有的绑定和缓存，后续调用不需要重复查找。

MethodHandle handle = MethodHandles.lookup()
    .findVirtual(TestClass.class, "doSomething", MethodType.methodType(void.class));

// 直接调用目标方法
handle.invokeExact(obj);

​