新的java一些技术

虚拟线程

它也称协程或纤程，是一种轻量级的线程实现，与传统的线程及操作系统的线程相比，开销更小、资源利用率更高，是并发领域的一项创新。JDK19 开始加入，JDK 21才稳定提供。

// 创建线程并启动
Thread.startVirtualThread(() -> System.out.println("1-Hello World!"));

// 创建线程，然后启动
Thread thread = Thread.ofVirtual().unstarted(() -> System.out.println("2-Hello World!"));
thread.start();

// 创建线程工厂，制造线程，然后启动
ThreadFactory factory = Thread.ofVirtual().factory();
factory.newThread(() -> System.out.println("3-Hello World!")).start();

// 创建线程池
try (ExecutorService executorService = Executors.newVirtualThreadPerTaskExecutor()) {
    executorService.submit(() -> System.out.println("4-Hello World!"));
}

虚拟线程和普通线程的区别：

1.普通线程与操作系统的物理线程一一对应，而虚拟线程是JVM层面的逻辑线程，而不用去与物理线程一一对应，可以看作是轻量级线程。

2.普通线程创建默认是用户线程，虚拟线程是守护线程且不可修改（修改会报错）

3.虚拟线程由JVM调用和使用，避免了普通线程频繁切换的性能开销，运行效率更高。

springboot开启虚拟线程

application.yml

 spring:
  threads:
    virtual:
      enable: true

或

@Configuration
public class TomcatCfg {
    
    @Bean
    public TomcatProtocolHandlerCustomizer<?> protocolHandlerVirtualThreadPerTaskExecutorCustomizer() {
        return protocolHandler -> protocolHandler.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
    }
}

springboot在启动Tomcat容器时，使用一个虚拟线程执行器来代表原来的平台线程池。

异步任务开启虚拟线程

@Configuration
@EnableAsync
public class AsynTaskCfg implements AsyncConfigurer {
    @Override
    public Executor getAsyncExecutor() {
        return new TaskExecutorAdapter(Executors.newThreadPerTaskExecutor(Thread.ofVirtual().name("virtual-fg", 1).factory()));
    }
}

新的技术

自 Java 9 以来，Java 平台引入了许多新的技术和功能。以下是其中的一些：

1. 模块化系统（Project Jigsaw）：Java 9 引入了模块化系统，使得可以将代码组织成为相互依赖的模块，从而提高了代码的可维护性和安全性。

module com.example.myapp {
    requires com.example.mylib;
}

2. JShell：JShell 是 Java 9 引入的交互式编程工具，使得可以更加便捷地进行代码实验和学习。

// 在命令行中运行
$ jshell
|  Welcome to JShell -- Version 9
|  For an introduction type: /help intro

jshell> int a = 5
a ==> 5

jshell> int b = 3
b ==> 3

jshell> a + b
$3 ==> 8

3. 接口私有方法：Java 9 允许接口中包含私有方法的实现，从而使得可以在接口中组织重复的代码。

public interface MyInterface {
    default void normalMethod() {
        // 调用私有方法
        int result = privateMethod(5, 3);
        System.out.println("Result: " + result);
    }
    
    private int privateMethod(int a, int b) {
        // 私有方法实现
        return a + b;
    }
}

4. HTTP/2 客户端：Java 9 引入了对 HTTP/2 协议的支持，包括新的 HTTP 客户端 API。

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;

public class HttpClientExample {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("http://www.example.com"))
                .build();
        
        CompletableFuture<HttpResponse<String>> response = client.sendAsync(request, HttpResponse.BodyHandlers.ofString());
        
        response.thenAccept(res -> System.out.println(res.body()));
    }
}

5. 钻石操作符的增强：Java 9 对钻石操作符做出了改进，可以在匿名内部类和匿名对象创建时使用钻石操作符。

import java.util.ArrayList;

public class DiamondOperatorExample {
    public static void main(String[] args) {
        // 在 Java 7/8 中，使用匿名内部类创建 ArrayList
        ArrayList<String> list1 = new ArrayList<String>() {
            // 匿名内部类内容
        };

        // 在 Java 9 中，可以使用钻石操作符
        ArrayList<String> list2 = new ArrayList<>() {
            // 匿名内部类内容
        };

        // 输出两个 ArrayList 实例
        System.out.println(list1.getClass()); // 输出 class ArrayList
        System.out.println(list2.getClass()); // 输出 class ArrayList
    }
}

6. Reactive Streams API：Java 9 引入了 Reactive Streams API，用于支持响应式编程模型。

import java.util.concurrent.Flow.*;

public class SimpleReactiveStreamsExample {
    public static void main(String[] args) {
        // 创建一个简单的发布者
        Publisher<String> publisher = subscriber -> {
            subscriber.onNext("Hello");
            subscriber.onNext("Reactive");
            subscriber.onNext("Streams");
            subscriber.onComplete();
        };

        // 创建一个订阅者
        Subscriber<String> subscriber = new Subscriber<>() {
            private Subscription subscription;

            @Override
            public void onSubscribe(Subscription subscription) {
                this.subscription = subscription;
                this.subscription.request(3); // 请求三个元素
            }

            @Override
            public void onNext(String item) {
                System.out.println("Received: " + item);
            }

            @Override
            public void onError(Throwable throwable) {
                System.err.println("Error: " + throwable.getMessage());
            }

            @Override
            public void onComplete() {
                System.out.println("Completed");
            }
        };

        // 订阅发布者
        publisher.subscribe(subscriber);
    }
}

7. 改进的 Javadoc：Java 9 对 Javadoc 进行了改进，支持了基于模块的文档生成以及新的标记语言。

/**
 * This is a module-level doc comment
 * @author John Doe
 * @version 1.0
 * @since 9
 */
module com.example.myapp {
    // module declaration
}

8. 改进的性能和安全性：Java 9 对性能和安全性做出了一些改进，例如 G1 垃圾收集器的默认启用、改进的 TLS 1.3 支持等。

这些是 Java 9 以后引入的一些新技术和功能，它们使得 Java 平台更加现代化、高效和安全。