Virtual Threads & Structured Concurrency (Java 21+)

// ❌ Old way: limited by thread pool size
ExecutorService executor = Executors.newFixedThreadPool(200);  // can't create millions

// Each thread costs ~1MB stack space
// 200 threads = 200MB just for stacks
// If all threads are blocked on I/O → server is at capacity even though CPU is idle

// ✅ New way: unlimited virtual threads
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();

// Each virtual thread costs ~few KB
// 1,000,000 virtual threads = a few GB (not terabytes)
// When a virtual thread blocks on I/O → it unmounts from carrier, carrier serves another

// Method 1: Thread.ofVirtual()
Thread vThread = Thread.ofVirtual()
    .name("worker-", 0)  // worker-0, worker-1, ...
    .start(() -> {
        String result = callExternalApi();  // blocks, but cheaply!
        processResult(result);
    });

// Method 2: ExecutorService (recommended for most use cases)
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 100_000).forEach(i ->
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));  // 100K threads sleeping = no problem
            return fetchData(i);
        })
    );
}  // auto-shutdown on close

// Method 3: Thread.startVirtualThread (fire and forget)
Thread.startVirtualThread(() -> sendNotification(userId));

// This simple blocking code NOW scales to thousands of concurrent requests
@GetMapping("/orders/{id}")
public OrderResponse getOrder(@PathVariable String id) {
    Order order = orderRepository.findById(id).orElseThrow();    // blocks (DB call)
    Payment payment = paymentClient.getPayment(order.getPaymentId()); // blocks (HTTP)
    Inventory stock = inventoryClient.getStock(order.getItemId());     // blocks (HTTP)
    return new OrderResponse(order, payment, stock);
}
// Each request uses 3 blocking calls, but virtual threads make this scale beautifully

// ❌ Old way: manual CompletableFuture orchestration
CompletableFuture<User> userFuture = CompletableFuture.supplyAsync(() -> getUser(id));
CompletableFuture<List<Order>> ordersFuture = CompletableFuture.supplyAsync(() -> getOrders(id));
CompletableFuture<Recommendations> recsFuture = CompletableFuture.supplyAsync(() -> getRecs(id));
// If getUser() fails, orders and recs keep running wastefully
// Error handling is scattered and complex

// ✅ New way: Structured Concurrency
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Subtask<User> user = scope.fork(() -> getUser(id));
    Subtask<List<Order>> orders = scope.fork(() -> getOrders(id));
    Subtask<Recommendations> recs = scope.fork(() -> getRecs(id));

    scope.join();           // wait for all
    scope.throwIfFailed();  // propagate first failure

    // All succeeded — safe to use results
    return new UserProfile(user.get(), orders.get(), recs.get());
}
// If ANY subtask fails → all others are cancelled immediately
// Thread dumps show parent-child relationship clearly

// ❌ ThreadLocal — leaks in virtual threads, manual cleanup needed
private static final ThreadLocal<UserContext> CONTEXT = new ThreadLocal<>();

// ✅ ScopedValue — automatically scoped, no cleanup, immutable
private static final ScopedValue<UserContext> CONTEXT = ScopedValue.newInstance();

// Bind for a scope — automatically cleaned up
ScopedValue.runWhere(CONTEXT, new UserContext(userId, roles), () -> {
    orderService.processOrder(request);  // can read CONTEXT.get()
    // child virtual threads inherit the scoped value!
});