Java 23新特性生产适配指南：虚拟线程与模式匹配的性能调优实战

1

ExecutorService executor = Executors.newFixedThreadPool(200);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 方式1：无限制虚拟线程池（IO密集型场景推荐）
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();

// 方式2：带并发限制的虚拟线程池（下游有并发限制场景推荐）
ExecutorService executor = new ThreadPoolExecutor(
    0, Integer.MAX_VALUE,
    60L, TimeUnit.SECONDS,
    new SynchronousQueue<>(),
    Thread.ofVirtual().name("order-processor-", 0).factory()
);
// 配合Semaphore做并发控制：仅允许同时100个请求访问下游
Semaphore semaphore = new Semaphore(100);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 旧代码
private static final ThreadLocal<UserContext> USER_CONTEXT = new ThreadLocal<>();

// 新代码
private static final ScopedValue<UserContext> USER_CONTEXT = ScopedValue.newInstance();

// 上下文传递方式
public void process(Request request) {
    UserContext context = buildContext(request);
    ScopedValue.where(USER_CONTEXT, context).run(() -> {
        // 子任务中可以直接获取上下文
        doProcess();
    });
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public String handle(Object obj) {
    if (obj instanceof String s) {
        return "String: " + s;
    } else if (obj instanceof Integer i) {
        return "Integer: " + i;
    } else if (obj instanceof Double d) {
        return "Double: " + d;
    } else {
        return "Unknown: " + obj;
    }
}

1
2
3
4
5
6
7
8

public String handle(Object obj) {
    return switch (obj) {
        case String s -> "String: " + s;
        case Integer i -> "Integer: " + i;
        case Double d -> "Double: " + d;
        default -> "Unknown: " + obj;
    };
}

1
2
3
4
5
6
7
8

public String handle(String s) {
    return switch (s) {
        case null -> "Null value";
        case "success" -> "操作成功";
        case "fail" -> "操作失败";
        default -> "未知状态";
    };
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

record Order(Long id, Integer status, BigDecimal amount) {}

public String handleOrder(Order order) {
    return switch (order) {
        case Order(Long id, 1, BigDecimal amount) when amount.compareTo(BigDecimal.valueOf(1000)) > 0 -> 
            "大额待支付订单：" + id + "，金额：" + amount;
        case Order(Long id, 2, _) -> "已支付订单：" + id;
        case Order(Long id, 3, _) -> "已取消订单：" + id;
        default -> "未知订单状态";
    };
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 传统并行调用两个接口，代码复杂，容易出现资源泄漏
public OrderVO getOrder(Long orderId) throws ExecutionException, InterruptedException {
    ExecutorService executor = Executors.newFixedThreadPool(2);
    Future<OrderInfo> infoFuture = executor.submit(() -> getOrderInfo(orderId));
    Future<OrderItem> itemFuture = executor.submit(() -> getOrderItems(orderId));
    
    OrderInfo info = infoFuture.get();
    OrderItem item = itemFuture.get();
    executor.shutdown();
    return new OrderVO(info, item);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import java.util.concurrent.StructuredTaskScope;

public OrderVO getOrder(Long orderId) throws ExecutionException, InterruptedException {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
        var infoFuture = scope.fork(() -> getOrderInfo(orderId));
        var itemFuture = scope.fork(() -> getOrderItems(orderId));
        
        scope.join(); // 等待所有任务完成
        scope.throwIfFailed(); // 任何任务失败都抛出异常，自动取消所有其他任务
        
        return new OrderVO(infoFuture.resultNow(), itemFuture.resultNow());
    }
    //  scope会自动关闭，所有任务都会被取消，不会有资源泄漏
}