嗨，朋友，你还在用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）

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

下载地址：jdk.java.net/23/

发行说明：jdk.java.net/23/release-…

发版履历：www.oracle.com/news/announ…

特性和改进

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 8Java 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);

​

posted @   张不惑  阅读(124)  评论(0)  编辑  收藏  举报  
相关博文：
· 你发任你发，我用Java8！
· 日志传习录（上篇）· 记录日志
· JDK 23 新特性解析
· Java22~24的新特性
· Java 23连夜官宣发布，IDEA亲测可用！
阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 单线程的Redis速度为什么快？
点击右上角即可分享
微信分享提示
AI FOR CODE 大赛