#Java 21+ 并发新特性

// 创建虚拟线程
Thread vt = Thread.ofVirtual().start(() -> {
    System.out.println("Running in virtual thread");
});

// 虚拟线程执行器
try (ExecutorService executor =
        Executors.newVirtualThreadPerTaskExecutor()) {
    Future<String> future = executor.submit(() -> "result");
    System.out.println(future.get());
}

// 1. ThreadLocal 可能被虚拟线程复用
// 2. synchronized 可能阻塞 Carrier 线程
// 3. CPU 密集型任务仍用平台线程

// ShutdownOnFailure：所有任务必须成功
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future<String> f1 = scope.fork(() -> task1());
    Future<String> f2 = scope.fork(() -> task2());

    scope.join();
    scope.throwIfFailed();

    String result = f1.resultNow() + f2.resultNow();
}

// ShutdownOnSuccess：第一个成功即可
try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>() {
    scope.fork(() -> tryPrimary());
    scope.fork(() -> trySecondary());

    scope.join();
    String result = scope.result();
}

try (var executor = Executors.newVirtualThreadPerTaskExecutor();
     var scope = new StructuredTaskScope.ShutdownOnFailure(executor)) {

    scope.fork(() -> fetchUser(id));
    scope.fork(() -> fetchOrders(id));
    scope.fork(() -> fetchRecommendations(id));

    scope.join();
    scope.throwIfFailed();

    return new UserProfile(
        userFuture.resultNow(),
        ordersFuture.resultNow(),
        recsFuture.resultNow()
    );
}

public static final ScopedValue<String> REQUEST_ID = ScopedValue.newInstance();

// 设置和获取
ScopedValue.where(REQUEST_ID, "abc", () -> {
    String id = REQUEST_ID.get();  // "abc"
});

// 嵌套作用域
ScopedValue.where(REQUEST_ID, "outer", () -> {
    System.out.println(REQUEST_ID.get());  // "outer"

    ScopedValue.where(REQUEST_ID, "inner", () -> {
        System.out.println(REQUEST_ID.get());  // "inner"
    });

    System.out.println(REQUEST_ID.get());  // "outer" - 自动恢复
});

// JDK 21 新增接口
public interface SequencedCollection<E> extends Collection<E> {
    SequencedCollection<E> reversed();
    void addFirst(E);
    void addLast(E);
    E getFirst();
    E getLast();
    E removeFirst();
    E removeLast();
}

// LinkedList 已实现
LinkedList<String> list = new LinkedList<>();
list.addFirst("first");
list.addLast("last");
String first = list.getFirst();

// String Templates（预览）
String name = "World";
String greeting = STR."Hello, \{name}!";

// Record Patterns（正式）
record Point(int x, int y) {}
if (obj instanceof Point(int x, int y)) {
    // 直接解构
}

// switch 模式匹配（正式）
return switch (obj) {
    case String s -> "String: " + s;
    case Integer i -> "Integer: " + i;
    default -> "Unknown";
};

// JDK 8-20 → JDK 21

// 1. 线程池迁移
// 旧
ExecutorService executor = Executors.newFixedThreadPool(100);

// 新
try (ExecutorService executor =
        Executors.newVirtualThreadPerTaskExecutor()) {
    // 使用虚拟线程
}

// 2. ThreadLocal → ScopedValue
// 旧
ThreadLocal<String> requestId = new ThreadLocal<>();
requestId.set("abc");
String id = requestId.get();

// 新
ScopedValue<String> requestId = ScopedValue.newInstance();
ScopedValue.where(requestId, "abc", () -> {
    String id = requestId.get();
});

// 3. Future 链 → CompletableFuture + 结构化并发
// 使用新的结构化并发 API

// JDK 21 兼容旧代码
// 虚拟线程可以调用旧代码
// 旧代码也可以在虚拟线程中运行

// 但要注意
// - 不要混合使用虚拟线程和平台线程池
// - ThreadLocal 需要重新评估
// - synchronized 高竞争可能有问题

// 1. IO 密集型：虚拟线程 + 结构化并发
try (var executor = Executors.newVirtualThreadPerTaskExecutor();
     var scope = new StructuredTaskScope.ShutdownOnFailure(executor)) {
    // 最佳实践
}

// 2. CPU 密集型：平台线程
ExecutorService cpuExecutor =
    Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

// 3. 混合型：分开处理
Map<ExecutorService, List<Runnable>> tasks = new HashMap<>();
// 分流到不同的执行器

public class ModernHttpService {

    private static final ScopedValue<String> REQUEST_ID = ScopedValue.newInstance();

    private final HttpClient httpClient;
    private final ExecutorService virtualExecutor;
    private final ExecutorService cpuExecutor;

    public ModernHttpService() {
        this.virtualExecutor = Executors.newVirtualThreadPerTaskExecutor();
        this.cpuExecutor = Executors.newFixedThreadPool(
            Runtime.getRuntime().availableProcessors()
        );
        this.httpClient = HttpClient.newBuilder()
            .executor(virtualExecutor)
            .build();
    }

    public UserProfile getUserProfile(Long userId) {
        String requestId = generateRequestId();

        return ScopedValue.where(REQUEST_ID, requestId, () -> {
            try (var scope =
                    new StructuredTaskScope.ShutdownOnFailure(virtualExecutor)) {

                Future<User> userFuture = scope.fork(() -> fetchUser(userId));
                Future<List<Order>> ordersFuture =
                    scope.fork(() -> fetchOrders(userId));

                scope.join();
                scope.throwIfFailed();

                return new UserProfile(
                    userFuture.resultNow(),
                    ordersFuture.resultNow()
                );
            }
        });
    }

    private User fetchUser(Long userId) {
        String id = REQUEST_ID.get();  // Scoped Value 可访问
        // ...
    }

    public void shutdown() {
        virtualExecutor.close();
        cpuExecutor.close();
    }
}