JDK 21 新特性

// 方式一：Thread.startVirtualThread()
Thread vt = Thread.startVirtualThread(() -> {
    System.out.println("Hello Virtual Thread");
});
 
// 方式二：Thread.ofVirtual()
Thread vt = Thread.ofVirtual().start(() -> {
    System.out.println("Hello");
});
 
// 方式三：Executors
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> "Hello");
}
 
// 方式四：ThreadFactory
ThreadFactory factory = Thread.ofVirtual().factory();
Thread vt = factory.newThread(() -> {});

// 传统线程池：受限
try (var executor = Executors.newFixedThreadPool(200)) {
    for (int i = 0; i < 10000; i++) {
        executor.submit(() -> {
            Thread.sleep(1000);  // 阻塞
            return "Done";
        });
    }
}  // 200 个线程，10000 个任务排队
 
// 虚拟线程：无压力
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10000; i++) {
        executor.submit(() -> {
            Thread.sleep(1000);  // 阻塞但挂起虚拟线程
            return "Done";
        });
    }
}  // 10000 个虚拟线程并行

// 不要与平台线程池混用
// ❌ 错误：虚拟线程执行 CPU 密集任务
Executors.newVirtualThreadPerTaskExecutor()
    .submit(() -> fibonacci(40));  // 占用 CPU，阻塞载体线程
 
// ✅ 正确：虚拟线程适合 IO 密集任务
Executors.newVirtualThreadPerTaskExecutor()
    .submit(() -> httpClient.send(request));  // IO 等待时不占 CPU
 
// synchronized 问题：会钉住载体线程
// ❌ 避免
public synchronized void method() {
    // 虚拟线程进入 synchronized 方法时会被钉住
}
 
// ✅ 使用 ReentrantLock
private final Lock lock = new ReentrantLock();
public void method() {
    lock.lock();
    try {
        // 虚拟线程可以正常挂起
    } finally {
        lock.unlock();
    }
}

// SequencedCollection：有序集合
interface SequencedCollection<E> extends Collection<E> {
    SequencedCollection<E> reversed();  // 反转视图
    void addFirst(E e);                 // 添加到头部
    void addLast(E e);                  // 添加到尾部
    E getFirst();                       // 获取首元素
    E getLast();                        // 获取尾元素
    E removeFirst();                    // 移除首元素
    E removeLast();                     // 移除尾元素
}
 
// SequencedSet：有序 Set
interface SequencedSet<E> extends Set<E>, SequencedCollection<E> { }
 
// SequencedMap：有序 Map
interface SequencedMap<K, V> extends Map<K, V> {
    SequencedMap<K, V> reversed();
    SequencedSet<K> sequencedKeySet();
    SequencedCollection<V> sequencedValues();
    SequencedSet<Entry<K, V>> sequencedEntrySet();
    V putFirst(K k, V v);
    V putLast(K k, V v);
    Entry<K, V> firstEntry();
    Entry<K, V> lastEntry();
    Entry<K, V> pollFirstEntry();
    Entry<K, V> pollLastEntry();
}

// ArrayList
ArrayList<Integer> list = new ArrayList<>(List.of(1, 2, 3, 4, 5));
list.getFirst();     // 1
list.getLast();      // 5
list.addFirst(0);    // [0, 1, 2, 3, 4, 5]
list.addLast(6);     // [0, 1, 2, 3, 4, 5, 6]
list.reversed();     // [6, 5, 4, 3, 2, 1, 0]
 
// LinkedList
LinkedList<String> linked = new LinkedList<>();
linked.addFirst("a");
 
// LinkedHashSet
LinkedHashSet<String> set = new LinkedHashSet<>();
set.addFirst("first");
set.addLast("last");
 
// LinkedHashMap
LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
map.putFirst("a", 1);
map.putLast("b", 2);
map.firstEntry();  // a=1
map.lastEntry();   // b=2

record Point(int x, int y) { }
 
// JDK 16
if (obj instanceof Point p) {
    int x = p.x();
    int y = p.y();
}
 
// JDK 21：解构
if (obj instanceof Point(int x, int y)) {
    System.out.println(x + ", " + y);
}
 
// 嵌套解构
record Rectangle(Point upperLeft, Point lowerRight) { }
 
if (obj instanceof Rectangle(Point(int x1, int y1), Point(int x2, int y2))) {
    // 直接获取四个坐标
}
 
// switch 中使用
switch (obj) {
    case Point(int x, int y) -> System.out.println(x + y);
    default -> System.out.println("Not a point");
}

static String formatter(Object obj) {
    return switch (obj) {
        case Integer i -> "int: " + i;
        case Long l    -> "long: " + l;
        case Double d  -> "double: " + d;
        case String s  -> "string: " + s;
        default        -> "unknown";
    };
}
 
// 带守卫条件
static String categorize(Number n) {
    return switch (n) {
        case Integer i && i < 0  -> "negative int";
        case Integer i && i > 0  -> "positive int";
        case Integer i           -> "zero";
        case Double d  -> "double";
        default        -> "unknown";
    };
}
 
// 结合 Record 模式
sealed interface Shape permits Circle, Rectangle { }
record Circle(int radius) implements Shape { }
record Rectangle(int width, int height) implements Shape { }
 
static double area(Shape shape) {
    return switch (shape) {
        case Circle(int r) -> Math.PI * r * r;
        case Rectangle(int w, int h) -> w * h;
    };
}

# JDK 21 默认启用
java -XX:+UseZGC MyApp
 
# 指定堆大小
java -XX:+UseZGC -Xms4g -Xmx4g MyApp

// 传统字符串拼接
String name = "张三";
int age = 25;
String s = "姓名: " + name + ", 年龄: " + age;
 
// 字符串模板（JDK 21 预览）
String s = STR."姓名: \{name}, 年龄: \{age}";
 
// 多行模板
String json = STR."""
    {
        "name": "\{name}",
        "age": \{age}
    }
    """;
 
// 自定义模板处理器
StringTableProcessor STR = StringTableProcessor.INSTANCE;

// 传统：需要 class 包装
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}
 
// JDK 21 预览：顶级 main
void main() {
    System.out.println("Hello");
}