import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
/**
 * 虛擬線程 4種創(chuàng)建方式演示
 */
  public static void main(String[] args) throws InterruptedException {
        // 方式1：通過 Thread.startVirtualThread() 直接創(chuàng)建（最簡單）
        Thread.startVirtualThread(() -> {
            System.out.println("方式1：虛擬線程運(yùn)行中，線程類型：" + Thread.currentThread().getClass().getSimpleName());
            try {
                // 模擬I/O操作（睡眠100ms）
                TimeUnit.MILLISECONDS.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("方式1：虛擬線程執(zhí)行完畢");
        });
        // 方式2：通過 Thread.Builder 構(gòu)建（可設(shè)置線程名稱，移除不支持的優(yōu)先級）
        Thread virtualThread = Thread.ofVirtual()
                .name("virtual-thread-2") // 設(shè)置線程名稱（虛擬線程支持設(shè)置名稱）
                .unstarted(() -> {
                    System.out.println("方式2：虛擬線程運(yùn)行中，線程名稱：" + Thread.currentThread().getName());
                    try {
                        TimeUnit.MILLISECONDS.sleep(150);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println("方式2：虛擬線程執(zhí)行完畢");
                });
        virtualThread.start(); // 啟動虛擬線程
        // 方式3：通過線程池創(chuàng)建（推薦，適合批量管理并發(fā)任務(wù)）
        // newVirtualThreadPerTaskExecutor()：每個任務(wù)對應(yīng)一個虛擬線程
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 5; i++) {
                int taskId = i;
                executor.submit(() -> {
                    System.out.println("方式3：虛擬線程任務(wù)" + taskId + "運(yùn)行中，線程ID：" + Thread.currentThread().threadId());
                    try {
                        TimeUnit.MILLISECONDS.sleep(200);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println("方式3：虛擬線程任務(wù)" + taskId + "執(zhí)行完畢");
                });
            }
        } // try-with-resources 自動關(guān)閉線程池，無需手動shutdown
        // 方式4：通過 ThreadFactory 創(chuàng)建（靈活定制線程屬性）
        // 替換 namePrefix 為 name(prefix, start)，移除無效的 daemon 方法
        ThreadFactory factory = Thread.ofVirtual()
                .name("custom-virtual-thread-", 0) // 名稱前綴 + 起始數(shù)字（0開始）
                .factory();
        Thread customThread = factory.newThread(() -> {
            System.out.println("方式4：自定義虛擬線程運(yùn)行中，線程名稱：" + Thread.currentThread().getName());
            try {
                TimeUnit.MILLISECONDS.sleep(250);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("方式4：自定義虛擬線程執(zhí)行完畢");
        });
        customThread.start();
        // 等待所有虛擬線程執(zhí)行完畢（主線程阻塞，避免程序提前退出）
        TimeUnit.SECONDS.sleep(1);
        System.out.println("所有虛擬線程執(zhí)行完畢，主線程退出");
    }

import java.util.Objects;
/**
 * switch 模式匹配 5種常見場景演示
 * 要求：Java 21+ 版本運(yùn)行（所有特性均為正式特性）
 */
public class SwitchPatternMatchingDemo {
    public static void main(String[] args) {
        // 場景1：類型模式匹配（替代 instanceof + 強(qiáng)轉(zhuǎn)）
        Object obj1 = "JDK21";
        String typeResult = switch (obj1) {
            case String s -> "字符串類型，長度：" + s.length();
            case Integer i -> "整數(shù)類型，值：" + i;
            case Double d -> "浮點(diǎn)數(shù)類型，值：" + d;
            default -> "未知類型";
        };
        System.out.println("場景1結(jié)果：" + typeResult);
        // 場景2：null 匹配（無需外部判斷空值）
        String str = null;
        System.out.print("場景2結(jié)果：");
        switch (str) {
            case null -> System.out.println("字符串為null");
            case "JDK" -> System.out.println("字符串是JDK");
            default -> System.out.println("字符串：" + str);
        }
        // 場景3：條件守衛(wèi)（統(tǒng)一使用 when 子句，修復(fù) && 語法錯誤）
        Object obj2 = 42;
        System.out.print("場景3結(jié)果：");
        switch (obj2) {
            case Integer i when i < 18 -> System.out.println("未成年，年齡：" + i);
            case Integer i when i >= 18 && i <= 60 -> System.out.println("成年，年齡：" + i);
            case Integer i -> System.out.println("老年，年齡：" + i);
            case String s when s.length() > 5 -> System.out.println("字符串長度大于5：" + s);
            default -> System.out.println("未知數(shù)據(jù)");
        }
        // 場景4：結(jié)合密封類（窮盡性檢查，編譯器自動校驗(yàn)）
        Shape shape = new Circle(5.0);
        double area = switch (shape) {
            case Circle c -> Math.PI * c.radius() * c.radius();
            case Rectangle r -> r.width() * r.height();
            case Triangle t -> (t.base() * t.height()) / 2.0;
            // 無需default，編譯器會檢查密封類的所有子類是否都被覆蓋
        };
        System.out.println("場景4結(jié)果：圖形面積：" + String.format("%.2f", area));
        // 場景5：記錄模式匹配（直接解構(gòu)記錄屬性）
        Person person = new Person("Alice", 30);
        String personInfo = switch (person) {
            case Person(String name, int age) when age < 18 -> "未成年人：" + name;
            case Person(String name, int age) -> "成年人：" + name + "（" + age + "歲）";
        };
        System.out.println("場景5結(jié)果：" + personInfo);
    }
    // 密封類：限制子類只能是指定的幾個類（配合switch實(shí)現(xiàn)窮盡性檢查）
    public sealed interface Shape permits Circle, Rectangle, Triangle {}
    // 密封類的子類，必須使用final、sealed或non-sealed修飾（record默認(rèn)final，符合要求）
    public record Circle(double radius) implements Shape {}
    public record Rectangle(double width, double height) implements Shape {}
    public record Triangle(double base, double height) implements Shape {}
    // 記錄類：用于演示記錄模式匹配
    public record Person(String name, int age) {}
}

import java.time.LocalDate;
/**
 * 記錄（Record）模式匹配 - 解構(gòu)演示（修復(fù)未命名模式兼容問題）
 * 要求：Java 21+
 */
public class RecordPatternMatchingDemo {
    // 基礎(chǔ)記錄（無嵌套）
    public record Point(int x, int y) {}
    // 嵌套記錄（包含Point記錄）
    public record ColoredPoint(Point point, String color) {}
    // 多層嵌套記錄（包含ColoredPoint記錄）
    public record Rectangle(ColoredPoint upperLeft, ColoredPoint lowerRight) {}
    // 復(fù)雜業(yè)務(wù)記錄（包含嵌套記錄和普通類型）
    public record Order(String orderId, LocalDate createTime, ColoredPoint deliveryAddress) {}
    public static void main(String[] args) {
        // 場景1：基礎(chǔ)記錄解構(gòu)（直接提取Point的x和y）
        Point point = new Point(10, 20);
        if (point instanceof Point(int x, int y)) {
            System.out.println("場景1：基礎(chǔ)解構(gòu) - x=" + x + ", y=" + y);
        }
        // 場景2：嵌套記錄解構(gòu)（提取ColoredPoint中的Point組件）
        ColoredPoint coloredPoint = new ColoredPoint(new Point(5, 8), "red");
        if (coloredPoint instanceof ColoredPoint(Point(int x, int y), String color)) {
            System.out.println("場景2：嵌套解構(gòu) - x=" + x + ", y=" + y + ", color=" + color);
        }
        // 場景3：多層嵌套解構(gòu)（提取Rectangle中的深層Point組件）
        Rectangle rectangle = new Rectangle(
                new ColoredPoint(new Point(1, 2), "blue"),
                new ColoredPoint(new Point(3, 4), "blue")
        );
        if (rectangle instanceof Rectangle(
                ColoredPoint(Point(int x1, int y1), String color1),
                ColoredPoint(Point(int x2, int y2), String color2)
        )) {
            System.out.println("場景3：多層嵌套解構(gòu) - " +
                    "左上角(" + x1 + "," + y1 + "," + color1 + "), " +
                    "右下角(" + x2 + "," + y2 + "," + color2 + ")");
        }
        // 場景4：部分解構(gòu)（替換_為顯式命名的忽略變量，解決兼容問題）
        Order order = new Order("ORD-2024-001", LocalDate.now(), new ColoredPoint(new Point(100, 200), "green"));
        if (order instanceof Order(String orderId, LocalDate ignoreCreateTime, ColoredPoint(Point(int x, int y), String ignoreColor))) {
            // 忽略ignoreCreateTime和ignoreColor，僅使用需要的變量
            System.out.println("場景4：部分解構(gòu) - 訂單ID：" + orderId + ", 配送坐標(biāo)：(" + x + "," + y + ")");
        }
        // 場景5：結(jié)合switch模式匹配（同樣替換_為ignore變量）
        Object obj = new ColoredPoint(new Point(3, 5), "green");
        String deconstructionResult = switch (obj) {
            case Point(int x, int y) -> "Point: (" + x + "," + y + ")";
            case ColoredPoint(Point(int x, int y), String color) -> "ColoredPoint: (" + x + "," + y + "), " + color;
            case Rectangle(ColoredPoint p1, ColoredPoint p2) -> "Rectangle: " + p1 + ", " + p2;
            case Order(String orderId, LocalDate ignoreTime, ColoredPoint ignoreAddr) -> "Order: " + orderId;
            default -> "未知記錄類型";
        };
        System.out.println("場景5：switch結(jié)合記錄模式 - " + deconstructionResult);
    }
}

package org.example.model;
/**
 * 密封類 + 密封接口 + 多層密封 演示
 * 要求：Java 21+
 */
public class SealedClassDemo {
    public static void main(String[] args) {
        // 測試密封類（靜態(tài)內(nèi)部類可直接實(shí)例化）
        Animal cat = new Cat();
        Animal dog = new Dog();
        Animal puppy = new Puppy();
        Animal bird = new Bird();
        System.out.println("貓的叫聲：" + cat.makeSound());
        System.out.println("狗的叫聲：" + dog.makeSound());
        System.out.println("小狗的叫聲：" + puppy.makeSound());
        System.out.println("鳥的叫聲：" + bird.makeSound());
        // 測試密封接口
        Fruit apple = new Apple();
        Fruit banana = new Banana();
        Fruit orange = new Orange();
        System.out.println("蘋果的顏色：" + apple.getColor());
        System.out.println("香蕉的顏色：" + banana.getColor());
        System.out.println("橙子的顏色：" + orange.getColor());
        // 測試窮盡性檢查（switch + 密封類）
        printAnimalType(cat);
        printAnimalType(dog);
        printAnimalType(puppy);
        printAnimalType(bird);
    }
    // 給sealed類添加abstract修飾符（包含抽象方法必須聲明為抽象類）
    // 密封+抽象類：僅允許 Cat、Dog、Bird 繼承
    public static abstract sealed class Animal permits Cat, Dog, Bird {
        public abstract String makeSound();
    }
    // final 子類：不可再繼承
    public static final class Cat extends Animal {
        @Override
        public String makeSound() {
            return "喵喵喵";
        }
    }
    // sealed 子類：可繼續(xù)限制子類（僅允許 Puppy 繼承）
    public static sealed class Dog extends Animal permits Puppy {
        @Override
        public String makeSound() {
            return "汪汪汪";
        }
    }
    // Dog 的子類，final 修飾
    public static final class Puppy extends Dog {
        @Override
        public String makeSound() {
            return "嗚嗚嗚（小狗叫）";
        }
    }
    // non-sealed 子類：開放繼承，允許任意類繼承
    public static non-sealed class Bird extends Animal {
        @Override
        public String makeSound() {
            return "嘰嘰喳喳";
        }
    }
    // 密封接口：僅允許 Apple、Banana、Orange 實(shí)現(xiàn)
    public static sealed interface Fruit permits Apple, Banana, Orange {
        String getColor();
    }
    public static final class Apple implements Fruit {
        @Override
        public String getColor() {
            return "紅色";
        }
    }
    public static final class Banana implements Fruit {
        @Override
        public String getColor() {
            return "黃色";
        }
    }
    public static non-sealed class Orange implements Fruit {
        @Override
        public String getColor() {
            return "橙色";
        }
    }
    // 結(jié)合switch實(shí)現(xiàn)窮盡性檢查
    // 調(diào)整匹配順序（先匹配Puppy，再匹配Dog），讓編譯器識別窮盡性
    private static void printAnimalType(Animal animal) {
        String type = switch (animal) {
            case Cat ignore -> "貓科動物";
            case Puppy ignore -> "犬科動物（小狗）"; // 先匹配Puppy（Dog的子類）
            case Dog ignore -> "犬科動物（成年犬）";  // 再匹配普通Dog
            case Bird ignore -> "鳥類動物";
        };
        System.out.println("動物類型：" + type);
    }
}

# 啟用分代 ZGC（JDK21 正式特性，無需解鎖實(shí)驗(yàn)性選項(xiàng)）
-XX:+UseZGC -XX:+ZGenerational
# 可選參數(shù)（優(yōu)化大堆場景）
-XX:ZHeapSize=10G        # 設(shè)置堆內(nèi)存總大小為10G
-XX:MaxGCPauseMillis=10  # 建議最大GC停頓時間（ZGC 會盡力滿足，非強(qiáng)制）
-XX:ZYoungGenSize=2G     # 設(shè)置年輕代初始大小為2G（默認(rèn)自動動態(tài)調(diào)整，無需手動配置）

# 運(yùn)行Spring Boot應(yīng)用并啟用分代ZGC（JDK21+）
java -XX:+UseZGC -XX:+ZGenerational -XX:ZHeapSize=20G -jar your-app.jar
# 進(jìn)階配置（指定年輕代大小+停頓時間目標(biāo)）
java -XX:+UseZGC -XX:+ZGenerational -XX:ZHeapSize=32G -XX:ZYoungGenSize=4G -XX:MaxGCPauseMillis=5 -jar your-app.jar

import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.SequencedCollection;
import java.util.SequencedMap;
import java.util.SequencedSet;
/**
 * 有序集合（Sequenced Collections）三大接口演示
 * 注意：使用LinkedList（而非ArrayList），因?yàn)槠渲С謅ddFirst()/addLast()
 */
public class SequencedCollectionsDemo {
    public static void main(String[] args) {
        // 場景1：SequencedCollection 演示（以 LinkedList 為例，支持addFirst/addLast）
        System.out.println("=== 場景1：SequencedCollection 演示 ===");
        SequencedCollection<Integer> collection = new LinkedList<>();
        collection.add(1);
        collection.addFirst(0); // 添加到頭部（LinkedList支持，ArrayList不支持）
        collection.addLast(2); // 添加到尾部
        System.out.println("集合元素：" + collection);
        System.out.println("第一個元素：" + collection.getFirst());
        System.out.println("最后一個元素：" + collection.getLast());
        SequencedCollection<Integer> reversedCollection = collection.reversed();
        System.out.println("反向集合：" + reversedCollection);
        collection.removeFirst(); // 刪除頭部元素
        collection.removeLast(); // 刪除尾部元素
        System.out.println("刪除首尾后：" + collection);
        // 場景2：SequencedSet 演示（以 LinkedHashSet 為例）
        System.out.println("\n=== 場景2：SequencedSet 演示 ===");
        SequencedSet<Integer> set = new LinkedHashSet<>();
        set.add(3);
        set.add(1);
        set.add(2);
        set.addFirst(0); // 添加到頭部
        set.addLast(4); // 添加到尾部
        System.out.println("Set元素（有序不重復(fù)）：" + set);
        System.out.println("第一個元素：" + set.getFirst());
        System.out.println("最后一個元素：" + set.getLast());
        SequencedSet<Integer> reversedSet = set.reversed();
        System.out.println("反向Set：" + reversedSet);
        // 場景3：SequencedMap 演示（以 LinkedHashMap 為例）
        System.out.println("\n=== 場景3：SequencedMap 演示 ===");
        SequencedMap<Integer, String> map = new LinkedHashMap<>();
        map.put(1, "Apple");
        map.put(2, "Banana");
        map.put(3, "Orange");
        map.putFirst(0, "Grape"); // 添加到頭部
        map.putLast(4, "Mango"); // 添加到尾部
        System.out.println("Map元素：" + map);
        System.out.println("第一個鍵值對：" + map.firstEntry());
        System.out.println("最后一個鍵值對：" + map.lastEntry());
        // 獲取有序的key、value、entry集合
        System.out.println("有序key集合：" + map.sequencedKeySet());
        System.out.println("有序value集合：" + map.sequencedValues());
        System.out.println("有序entry集合：" + map.sequencedEntrySet());
        // 移除首尾鍵值對
        map.pollFirstEntry(); // 移除并返回第一個鍵值對
        map.pollLastEntry(); // 移除并返回最后一個鍵值對
        System.out.println("移除首尾后：" + map);
        // 反向Map
        SequencedMap<Integer, String> reversedMap = map.reversed();
        System.out.println("反向Map：" + reversedMap);
    }
}

import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
/**
 * 字符串模板（預(yù)覽特性）完整用法演示
 * 編譯命令：javac --enable-preview --release 21 StringTemplateDemo.java
 * 運(yùn)行命令：java --enable-preview StringTemplateDemo
 */
public class StringTemplateDemo {
    // 測試方法：用于表達(dá)式調(diào)用
    private static String getName() {
        return "Java開發(fā)者";
    }
    // 自定義模板處理器：轉(zhuǎn)換為大寫格式（兼容null參數(shù)）
    private static class UpperCaseProcessor implements StringTemplate.Processor<String, RuntimeException> {
        @Override
        public String process(StringTemplate st) {
            // 拼接模板文本和表達(dá)式值，轉(zhuǎn)換為大寫
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < st.fragments().size(); i++) {
                sb.append(st.fragments().get(i));
                if (i < st.arguments().size()) {
                    Object arg = st.arguments().get(i);
                    // 兼容null參數(shù)，避免空指針
                    sb.append(arg == null ? "null" : arg.toString().toUpperCase());
                }
            }
            return sb.toString();
        }
    }
    public static void main(String[] args) {
        // 基礎(chǔ)信息
        String name = "Alice";
        int age = 30;
        double salary = 15000.50;
        String userInput = "<script>alert('攻擊')</script>"; // 修正：設(shè)置有注入風(fēng)險(xiǎn)的輸入
        // 場景1：STR處理器（基礎(chǔ)插值）
        String info1 = STR."姓名：\{name}，年齡：\{age}，薪資：\{salary}";
        System.out.println("場景1：STR基礎(chǔ)插值 - " + info1);
        // 場景2：STR處理器（表達(dá)式調(diào)用：變量、方法、計(jì)算）
        String info2 = STR."靜態(tài)變量：\{name}，方法調(diào)用：\{getName()}，計(jì)算結(jié)果：\{10 + 20 == 30 ? "正確" : "錯誤"}";
        System.out.println("場景2：STR表達(dá)式調(diào)用 - " + info2);
        // 場景3：FMT處理器（格式化）
        String info3 = FMT."姓名：%-10s\{name}，年齡：%03d\{age}，薪資：%.2f\{salary}";
        System.out.println("場景3：FMT格式化 - " + info3);
        // 場景4：RAW處理器（原始模板，自定義處理）
        StringTemplate rawTemplate = RAW."姓名：\{name}，年齡：\{age}";
        System.out.println("場景4：RAW原始文本 - " + rawTemplate.text());
        System.out.println("場景4：RAW插值后（STR處理） - " + STR.process(rawTemplate));
        // 場景5：多行字符串模板
        String info4 = STR."""
                個人信息：
                姓名：\{name}
                年齡：\{age}歲
                薪資：\{salary}元/月
                當(dāng)前時間：\{
                    // 多行表達(dá)式支持注釋
                    DateTimeFormatter.ofPattern("HH:mm:ss")
                                    .format(LocalTime.now())
                }
                """;
        System.out.println("場景5：多行模板 - " + info4);
        // 場景6：自定義模板處理器（修正調(diào)用語法）
        UpperCaseProcessor upperProcessor = new UpperCaseProcessor();
        StringTemplate upperTemplate = STR."姓名：\{name}，年齡：\{age}";
        String info5 = upperProcessor.process(upperTemplate);
        System.out.println("場景6：自定義處理器（大寫） - " + info5);
        // 場景7：安全說明：STR/FMT不自動轉(zhuǎn)義，防注入需自定義處理器
        String unsafeInfo = STR."用戶輸入：\{userInput}";
        System.out.println("場景7：未轉(zhuǎn)義輸入 - " + unsafeInfo);
    }
}

import java.util.concurrent.ExecutionException;
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
/**
 * 結(jié)構(gòu)化并發(fā)（預(yù)覽特性）演示
 * 編譯命令：javac --enable-preview --release 21 StructuredConcurrencyDemo.java
 * 運(yùn)行命令：java --enable-preview StructuredConcurrencyDemo
 */
public class StructuredConcurrencyDemo {
    public static void main(String[] args) throws InterruptedException {
        // 場景1：基礎(chǔ)結(jié)構(gòu)化并發(fā)（父子任務(wù)綁定）
        System.out.println("=== 場景1：基礎(chǔ)結(jié)構(gòu)化并發(fā) ===");
        try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
            // 提交子任務(wù)1（虛擬線程需顯式指定線程工廠，默認(rèn)平臺線程）
            scope.fork(() -> {
                TimeUnit.MILLISECONDS.sleep(100);
                return "子任務(wù)1執(zhí)行完成";
            });
            // 提交子任務(wù)2
            scope.fork(() -> {
                TimeUnit.MILLISECONDS.sleep(200);
                return "子任務(wù)2執(zhí)行完成";
            });
            // 等待子任務(wù)完成（ShutdownOnSuccess：任一成功則關(guān)閉其他任務(wù)）
            scope.join();
            // 獲取成功完成的子任務(wù)結(jié)果（第一個成功的）
            System.out.println("成功結(jié)果：" + scope.result());
        } // try-with-resources 自動關(guān)閉scope
        // 場景2：異常處理（子任務(wù)拋出異常，父任務(wù)統(tǒng)一捕獲）
        System.out.println("\n=== 場景2：異常處理 ===");
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            // 子任務(wù)3：拋出異常
            scope.fork(() -> {
                TimeUnit.MILLISECONDS.sleep(50);
                System.out.println("子任務(wù)3執(zhí)行中");
                throw new RuntimeException("子任務(wù)3執(zhí)行失敗");
            });
            // 子任務(wù)4：因子任務(wù)3失敗，會被提前終止，不會執(zhí)行到打印
            scope.fork(() -> {
                TimeUnit.MILLISECONDS.sleep(150);
                System.out.println("子任務(wù)4執(zhí)行完成");
                return "子任務(wù)4成功";
            });
            try {
                scope.join(); // 等待，ShutdownOnFailure：任一失敗則關(guān)閉
            } catch (ExecutionException e) {
                // 捕獲封裝的異常，實(shí)際異常在scope.failures()中
                System.out.println("捕獲到執(zhí)行異常：" + e.getMessage());
            }
            // 遍歷所有子任務(wù)的異常（核心：從failures()獲?。?
            scope.failures().forEach(ex -> System.out.println("子任務(wù)異常：" + ex.getMessage()));
        }
        // 場景3：手動取消任務(wù)
        System.out.println("\n=== 場景3：手動取消任務(wù) ===");
        try (var scope = new StructuredTaskScope<String>()) {
            // 子任務(wù)5：耗時任務(wù)
            var future1 = scope.fork(() -> {
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                    return "子任務(wù)5執(zhí)行完成";
                } catch (InterruptedException e) {
                    System.out.println("子任務(wù)5被取消");
                    return null;
                }
            });
            // 子任務(wù)6：快速完成
            var future2 = scope.fork(() -> {
                TimeUnit.MILLISECONDS.sleep(100);
                return "子任務(wù)6執(zhí)行完成";
            });
            // 等待150ms，或所有子任務(wù)完成
            try {
                scope.joinUntil(System.currentTimeMillis() + 150);
                if (future2.isDone()) {
                    System.out.println("子任務(wù)6結(jié)果：" + future2.resultNow());
                    scope.shutdown(); // 觸發(fā)子任務(wù)中斷（子任務(wù)5）
                }
            } catch (TimeoutException e) {
                System.out.println("等待超時");
            }
        }
    }
}

import jdk.incubator.vector.FloatVector;
import jdk.incubator.vector.VectorSpecies;
import java.util.Arrays;
/**
 * 向量API（孵化特性）演示 + 性能對比
 * 編譯命令：javac --release 21 --add-modules jdk.incubator.vector VectorAPIDemo.java
 * 運(yùn)行命令：java --add-modules jdk.incubator.vector VectorAPIDemo
 */
public class VectorAPIDemo {
    // 定義向量物種：自動適配當(dāng)前CPU最優(yōu)長度（推薦），float類型
    private static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;
    // 也可手動指定：FloatVector.SPECIES_128（128位，4個float）、FloatVector.SPECIES_256（256位，8個float）
    // 傳統(tǒng)循環(huán)計(jì)算：兩個float數(shù)組相加
    public static void arrayAddTraditional(float[] a, float[] b, float[] result) {
        for (int i = 0; i < a.length; i++) {
            result[i] = a[i] + b[i];
        }
    }
    // 向量API計(jì)算：兩個float數(shù)組相加（修正length()為length）
    public static void arrayAddVector(float[] a, float[] b, float[] result) {
        int i = 0;
        // 向量批量處理（每次處理SPECIES.length個元素）
        int upperBound = SPECIES.loopBound(a.length);
        for (; i < upperBound; i += SPECIES.length) { // 修正：length（屬性）而非length()
            // 從數(shù)組中加載向量
            FloatVector va = FloatVector.fromArray(SPECIES, a, i);
            FloatVector vb = FloatVector.fromArray(SPECIES, b, i);
            // 向量相加，結(jié)果存儲到數(shù)組
            va.add(vb).intoArray(result, i);
        }
        // 處理剩余不足一個向量長度的元素
        for (; i < a.length; i++) {
            result[i] = a[i] + b[i];
        }
    }
    public static void main(String[] args) {
        // 初始化兩個大數(shù)組（1000萬元素）
        int size = 10_000_000;
        float[] a = new float[size];
        float[] b = new float[size];
        float[] resultTraditional = new float[size];
        float[] resultVector = new float[size];
        // 填充數(shù)據(jù)（固定值，避免隨機(jī)數(shù)影響性能）
        Arrays.fill(a, 1.23f);
        Arrays.fill(b, 4.56f);
        // JIT預(yù)熱：先運(yùn)行一次，避免編譯開銷影響性能測試
        arrayAddTraditional(a, b, resultTraditional);
        arrayAddVector(a, b, resultVector);
        // 測試傳統(tǒng)循環(huán)性能（多次運(yùn)行取平均）
        long start = System.currentTimeMillis();
        for (int j = 0; j < 5; j++) {
            arrayAddTraditional(a, b, resultTraditional);
        }
        long traditionalTime = (System.currentTimeMillis() - start) / 5;
        System.out.println("傳統(tǒng)循環(huán)平均耗時：" + traditionalTime + "ms");
        // 測試向量API性能（多次運(yùn)行取平均）
        start = System.currentTimeMillis();
        for (int j = 0; j < 5; j++) {
            arrayAddVector(a, b, resultVector);
        }
        long vectorTime = (System.currentTimeMillis() - start) / 5;
        System.out.println("向量API平均耗時：" + vectorTime + "ms");
        // 驗(yàn)證結(jié)果一致性
        boolean isEqual = Arrays.equals(resultTraditional, resultVector);
        System.out.println("結(jié)果是否一致：" + isEqual);
        // 打印向量物種信息（當(dāng)前CPU適配的長度）
        System.out.println("當(dāng)前CPU最優(yōu)向量長度（float元素?cái)?shù)）：" + SPECIES.length);
    }
}