Virtual Threads (Project Loom)

// Create a single virtual thread
Thread vt = Thread.ofVirtual()
    .name("my-virtual-thread")
    .start(() -> {
        System.out.println("Running in virtual thread: "
            + Thread.currentThread().isVirtual()); // true
    });
vt.join();

// Virtual thread executor — one virtual thread per task
try (ExecutorService exec =
        Executors.newVirtualThreadPerTaskExecutor()) {

    List<Future<String>> futures = new ArrayList<>();
    for (int i = 0; i < 10_000; i++) {
        int taskId = i;
        futures.add(exec.submit(() -> {
            Thread.sleep(100); // blocks, but doesn't tie up OS thread
            return "result-" + taskId;
        }));
    }
    // All 10,000 tasks run concurrently without 10,000 OS threads
    for (Future<String> f : futures) System.out.println(f.get());
}

// Platform thread pool — limited by OS thread count
ExecutorService platform = Executors.newFixedThreadPool(200);

// Virtual thread executor — scales to millions
ExecutorService virtual = Executors.newVirtualThreadPerTaskExecutor();

// Benchmark: 10,000 tasks sleeping 1 second
// Platform pool (200 threads): ~50 seconds (10000 / 200)
// Virtual executor:             ~1 second  (all run concurrently)

// Virtual thread pitfalls:
// 1. Pinned threads — synchronized blocks pin the carrier
//    Fix: use ReentrantLock instead of synchronized for I/O inside
// 2. Thread-local misuse — ThreadLocal is expensive with millions of threads
//    Fix: use ScopedValue (Java 21 preview) instead

// Check if current thread is virtual
boolean isVirtual = Thread.currentThread().isVirtual();

import java.util.concurrent.*;

// StructuredTaskScope — parent waits for all children
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {

    // Fork subtasks
    Subtask<User>  user    = scope.fork(() -> fetchUser(userId));
    Subtask<Order> order   = scope.fork(() -> fetchOrder(orderId));
    Subtask<Stock> stock   = scope.fork(() -> checkStock(itemId));

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

    // All subtasks completed successfully
    return new Response(user.get(), order.get(), stock.get());

} // scope closed — all subtasks guaranteed to be done

// ShutdownOnSuccess — take first result, cancel the rest
try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
    scope.fork(() -> fetchFromPrimary());
    scope.fork(() -> fetchFromFallback());
    scope.join();
    return scope.result(); // fastest result
}