Virtual Threads en Java 21 vs ExecutorService

// Registra esto en cada arranque.
// Ha evitado más incidentes que cualquier dashboard.

Runtime rt = Runtime.getRuntime();

log.info("availableProcessors={} maxHeap={}MB",
         rt.availableProcessors(),
         rt.maxMemory() / 1_048_576);

// Era 1. El primer programa concurrente de todo desarrollador Java.

Thread t = new Thread(() -> {
    log.info("Ejecutando en {}", Thread.currentThread().getName());
});

t.start();
t.join();

Callable<Factura> tarea = () -> facturaService.generar(pedidoId);  // puede lanzar

Future<Factura> future = executor.submit(tarea);

// Bloquea el hilo actual y envuelve cualquier error en ExecutionException.
Factura factura = future.get();

// Desde Java 19, ExecutorService implementa AutoCloseable:
// close() hace un apagado ordenado y espera a la terminación.

try (ExecutorService executor = Executors.newFixedThreadPool(8)) {

    List<Future<Informe>> futures = regiones.stream()
        .map(region -> executor.submit(() -> informeService.generar(region)))
        .toList();

    for (Future<Informe> f : futures) {
        resultados.add(f.get());
    }

}   // close() → shutdown() + awaitTermination(Long.MAX_VALUE)

new ThreadPoolExecutor(

    8,                              // corePoolSize    se mantienen vivos aunque estén ociosos
    32,                             // maximumPoolSize solo se alcanza si la cola está LLENA
    60L, TimeUnit.SECONDS,          // keepAliveTime   para los hilos por encima del core

    new ArrayBlockingQueue<>(500),  // workQueue       acotada: ver la advertencia

    // Desde Java 21 no hace falta Guava para nombrar los hilos:
    // Thread.ofPlatform() devuelve una ThreadFactory del propio JDK.
    Thread.ofPlatform().name("pricing-", 0).factory(),

    new ThreadPoolExecutor.CallerRunsPolicy()   // backpressure natural
);

// Uso de manual: divide y vencerás intensivo en CPU.

class SumaTask extends RecursiveTask<Long> {

    private static final int UMBRAL = 10_000;

    private final long[] datos;
    private final int ini, fin;

    SumaTask(long[] datos, int ini, int fin) {
        this.datos = datos; this.ini = ini; this.fin = fin;
    }

    @Override
    protected Long compute() {

        if (fin - ini <= UMBRAL) {
            long suma = 0;
            for (int i = ini; i < fin; i++) suma += datos[i];
            return suma;
        }

        int medio = (ini + fin) >>> 1;

        SumaTask izq = new SumaTask(datos, ini, medio);
        izq.fork();                                            // encola en la deque del worker

        long der = new SumaTask(datos, medio, fin).compute();  // ejecuta en línea: ahorra una tarea

        return der + izq.join();
    }
}

// Órdenes de magnitud en un servidor x86-64 Linux moderno:

new Thread(tarea).start();          // ~50–100 µs   syscall clone + contabilidad del kernel

Thread.ofVirtual().start(tarea);    // ~1 µs        una reserva en el heap

pool.submit(tarea);                 // ~0,1–1 µs    encolar
                                    //              pero lo pagas en tiempo de cola

# Límites reales y duros con los que te chocarás antes de lo que crees

ulimit -u                       # máximo de procesos/hilos por usuario (a menudo 4096–63000)

cat /proc/sys/kernel/threads-max

cat /proc/sys/vm/max_map_count  # cada stack de hilo = un mapeo de memoria
                                # por defecto 65530: te capa muy por debajo
                                # de "un millón de hilos" por mucha RAM que tengas

// jdk.internal.vm.Continuation — API INTERNA.
// Se muestra para explicar el mecanismo, nunca para usarla en aplicación.

ContinuationScope scope = new ContinuationScope("demo");

Continuation continuation = new Continuation(scope, () -> {
    System.out.println("A");
    Continuation.yield(scope);   // freeze: copia la pila al heap y vuelve al llamante
    System.out.println("B");
    Continuation.yield(scope);   // freeze otra vez
    System.out.println("C");
});

continuation.run();   // imprime A y vuelve
continuation.run();   // imprime B y vuelve
continuation.run();   // imprime C

System.out.println(continuation.isDone());   // true

// En una máquina de 4 cores esto congela TODA la actividad
// de virtual threads de la JVM: no hay expropiación que los desaloje.

for (int i = 0; i < 4; i++) {
    Thread.ofVirtual().start(() -> {
        long x = 0;
        while (true) {
            x += ThreadLocalRandom.current().nextInt();   // nunca cede
        }
    });
}

// Java 21–23: esto bloquea el carrier durante toda la llamada HTTP.

public synchronized Cotizacion obtener(String simbolo) {
    return httpClient.send(request, ofString());   // carrier bloqueado
}


// Solución en Java 21–23: ReentrantLock sí se desmonta limpiamente.

private final ReentrantLock lock = new ReentrantLock();

public Cotizacion obtener(String simbolo) {
    lock.lock();
    try {
        return httpClient.send(request, ofString());   // hace unmount
    } finally {
        lock.unlock();
    }
}


// Java 24+: la versión original con synchronized vuelve a ser correcta.

# jstack NO muestra virtual threads. Usa jcmd.

jcmd <pid> Thread.dump_to_file -format=json /tmp/threads.json
jcmd <pid> Thread.dump_to_file -format=text /tmp/threads.txt


# Detección de pinning · solo Java 21–23
# La propiedad se eliminó en Java 24, donde JEP 491 la dejó obsoleta.

java -Djdk.tracePinnedThreads=full -jar app.jar


# Portable y apto para producción en cualquier versión: JFR

jcmd <pid> JFR.start name=loom settings=profile duration=120s filename=loom.jfr
jfr print --events jdk.VirtualThreadPinned,jdk.VirtualThreadSubmitFailed loom.jfr

// 1 · Dispara y olvida: la forma más directa
Thread vt = Thread.startVirtualThread(() -> log.info("hola"));


// 2 · Builder: nombrarlos importa muchísimo para la observabilidad
Thread.Builder.OfVirtual builder = Thread.ofVirtual().name("pedido-worker-", 0);
Thread t = builder.start(() -> procesarPedido(id));   // pedido-worker-0, -1, -2 …


// 3 · ThreadFactory: para APIs que esperan una
ThreadFactory factory = Thread.ofVirtual().name("ingesta-", 0).factory();


// 4 · Executor: la forma idiomática en producción
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    pedidos.forEach(pedido -> executor.submit(() -> procesar(pedido)));
}   // close() espera a que termine cada tarea

// Ya no dimensionas hilos. Dimensionas el recurso que de verdad es escaso.

private final Semaphore permisosBd    = new Semaphore(40);   // = máximo de HikariCP
private final Semaphore permisosPagos = new Semaphore(100);  // = límite del proveedor

public Recibo comprar(Pedido pedido) throws InterruptedException {

    permisosBd.acquire();
    try {
        pedidoRepository.save(pedido);
    } finally {
        permisosBd.release();
    }

    permisosPagos.acquire();
    try {
        return pasarelaPago.cobrar(pedido);
    } finally {
        permisosPagos.release();
    }
}

import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.*;
import java.util.function.Supplier;

public class LoomBenchmark {

    /** Simula una llamada bloqueante: 100 ms de espera y 0,05 ms de CPU. */
    static void tareaIoSimulada() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return;
        }
        long acc = 0;
        for (int i = 0; i < 20_000; i++) acc += i * 31L;
        if (acc == Long.MIN_VALUE) System.out.print("");   // evita eliminación de código muerto
    }

    record Resultado(String config, int tareas, Duration makespan) {
        double throughput() {
            return tareas / (makespan.toNanos() / 1_000_000_000.0);
        }
    }

    static Resultado run(String nombre, int tareas,
                         Supplier<ExecutorService> factory) throws Exception {

        System.gc();
        Thread.sleep(500);                       // deja que la JVM se estabilice

        Instant inicio = Instant.now();
        CountDownLatch fin = new CountDownLatch(tareas);

        try (ExecutorService executor = factory.get()) {
            for (int i = 0; i < tareas; i++) {
                executor.submit(() -> { tareaIoSimulada(); fin.countDown(); });
            }
            fin.await();
        }

        return new Resultado(nombre, tareas, Duration.between(inicio, Instant.now()));
    }

    public static void main(String[] args) throws Exception {

        // Calentamiento: nunca publiques un número obtenido con la JVM fría.
        run("warmup", 500, Executors::newVirtualThreadPerTaskExecutor);

        for (int n : new int[]{100, 1_000, 10_000, 100_000}) {
            imprimir(run("fixed-200", n, () -> Executors.newFixedThreadPool(200)));
            imprimir(run("cached",    n, Executors::newCachedThreadPool));
            imprimir(run("forkjoin",  n, () -> new ForkJoinPool(
                    Runtime.getRuntime().availableProcessors() - 1)));
            imprimir(run("virtual",   n, Executors::newVirtualThreadPerTaskExecutor));
        }
    }

    static void imprimir(Resultado r) {
        System.out.printf("%-18s n=%-7d %7d ms  %9.0f req/s%n",
                r.config(), r.tareas(), r.makespan().toMillis(), r.throughput());
    }
}

// Sin estructura. Cuatro formas independientes de tener fugas.

Future<Usuario> usuario = executor.submit(() -> usuarioService.buscar(id));
Future<Pedidos> pedidos = executor.submit(() -> pedidoService.buscarDe(id));
Future<Riesgo>  riesgo  = executor.submit(() -> riesgoService.calcular(id));

// Si usuarioService lanza, pedidos y riesgo siguen ejecutándose —quemando una
// conexión de base de datos cada uno— hasta terminar. Nadie los cancela.
// Si cancelan al llamante, los tres siguen vivos. Esto es una fuga de tareas.

return new Cuadro(usuario.get(), pedidos.get(), riesgo.get());

// Java 25 · JEP 505 · requiere --enable-preview

import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.StructuredTaskScope.Subtask;

Cuadro cargarCuadro(ClienteId id) throws Exception {

    // awaitAllSuccessfulOrThrow es el Joiner correcto cuando las subtareas
    // devuelven tipos distintos: espera a todas, propaga el primer fallo y no
    // intenta agregar resultados heterogéneos en un único Stream.
    try (var scope = StructuredTaskScope.open(
             StructuredTaskScope.Joiner.awaitAllSuccessfulOrThrow())) {

        Subtask<Usuario> usuario = scope.fork(() -> usuarioService.buscar(id));
        Subtask<Pedidos> pedidos = scope.fork(() -> pedidoService.buscarDe(id));
        Subtask<Riesgo>  riesgo  = scope.fork(() -> riesgoService.calcular(id));

        scope.join();      // espera a todas; al PRIMER fallo cancela el resto

        return new Cuadro(usuario.get(), pedidos.get(), riesgo.get());

    }   // close() garantiza que ninguna subtarea sobreviva a este bloque
}

// Carrera entre dos proveedores: gana la primera respuesta, la otra se cancela.

Tipo mejorTipo(String par) throws Exception {

    try (var scope = StructuredTaskScope.open(
             StructuredTaskScope.Joiner.<Tipo>anySuccessfulResultOrThrow())) {

        scope.fork(() -> bloombergClient.tipo(par));
        scope.fork(() -> reutersClient.tipo(par));

        return scope.join();      // devuelve el ganador
    }
}

// Java 25 · API definitiva, sin --enable-preview

public final class ContextoPeticion {

    public static final ScopedValue<TenantId> TENANT = ScopedValue.newInstance();
    public static final ScopedValue<TraceId>  TRACE  = ScopedValue.newInstance();

    private ContextoPeticion() {}
}


// Se enlaza en el borde: un filtro de servlet, un listener, un job programado.

ScopedValue.where(ContextoPeticion.TENANT, tenantId)
           .where(ContextoPeticion.TRACE,  traceId)
           .run(() -> atenderPeticion(request));


// Se lee en cualquier punto de la pila. Sin propagar parámetros, sin mutación.

public Factura generar(PedidoId id) {
    TenantId tenant = ContextoPeticion.TENANT.get();   // garantizado enlazado aquí
    return facturaRepository.buscarPara(tenant, id);
}


// Con valor de retorno.

Informe informe = ScopedValue.where(ContextoPeticion.TENANT, tenantId)
                             .call(() -> informeService.generar(criterios));

# application.properties — Spring Boot 3.2+ sobre Java 21+

spring.threads.virtual.enabled=true

# Esta propiedad queda SIN EFECTO con virtual threads activados.
server.tomcat.threads.max=200

# ESTE es ahora tu verdadero control de admisión.
server.tomcat.max-connections=10000
server.tomcat.accept-count=200
server.tomcat.connection-timeout=20s

// Un pipeline reactivo con una llamada bloqueante inevitable.

private final Scheduler schedulerBloqueante =
    Schedulers.fromExecutor(Executors.newVirtualThreadPerTaskExecutor());

public Mono<Enriquecido> enriquecer(Evento evento) {
    return Mono.fromCallable(() -> repositorioJdbcLegado.buscar(evento.clave()))
               .subscribeOn(schedulerBloqueante)   // sin el tope de boundedElastic
               .map(datos -> enriquecerCon(evento, datos));
}

@Configuration
@EnableAsync
class AsyncConfig {

    @Bean(name = "applicationTaskExecutor")
    AsyncTaskExecutor applicationTaskExecutor() {

        SimpleAsyncTaskExecutor executor = new SimpleAsyncTaskExecutor("async-vt-");
        executor.setVirtualThreads(true);          // Spring Framework 6.1+
        executor.setConcurrencyLimit(500);         // AÑADE ESTO. Por favor.
        return executor;
    }

    // Conserva un pool de platform threads para CPU:
    // los virtual threads no aportan nada aquí.
    @Bean("cpuBoundExecutor")
    ThreadPoolTaskExecutor cpuBoundExecutor() {

        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        int cores = Runtime.getRuntime().availableProcessors();

        executor.setCorePoolSize(cores);
        executor.setMaxPoolSize(cores);
        executor.setQueueCapacity(1_000);
        executor.setThreadNamePrefix("cpu-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();

        return executor;
    }
}


@Service
class InformeService {

    @Async                              // → virtual threads
    CompletableFuture<Void> enviarPorEmail(InformeId id) { /* SMTP bloqueante */ }

    @Async("cpuBoundExecutor")          // → pool de platform. Explícito y correcto.
    CompletableFuture<Pdf> renderizarPdf(InformeId id) { /* render intensivo */ }
}

@RestController
@RequestMapping("/api/clientes")
class CuadroClienteController {

    private final UsuarioClient usuarios;
    private final PedidoClient  pedidos;
    private final RiesgoClient  riesgo;

    // Un bulkhead por destino. Esta es la nueva disciplina de dimensionado.
    private final Semaphore permisosRiesgo = new Semaphore(50);

    CuadroClienteController(UsuarioClient u, PedidoClient p, RiesgoClient r) {
        this.usuarios = u; this.pedidos = p; this.riesgo = r;
    }

    @GetMapping("/{id}/cuadro")
    Cuadro cuadro(@PathVariable ClienteId id) throws Exception {

        // Fan-out con aspecto secuencial, sobre el virtual thread de la petición.
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {

            Future<Usuario> u = executor.submit(() -> usuarios.buscar(id));
            Future<Pedidos> p = executor.submit(() -> pedidos.recientesDe(id));
            Future<Riesgo>  r = executor.submit(() ->
                    conPermiso(permisosRiesgo, () -> riesgo.calcular(id)));

            return new Cuadro(u.get(), p.get(), r.get());
        }
    }

    private static <T> T conPermiso(Semaphore permisos, Callable<T> tarea) throws Exception {
        permisos.acquire();
        try { return tarea.call(); } finally { permisos.release(); }
    }
}

# El pool de conexiones es ahora tu límite REAL de concurrencia.

spring.datasource.hikari.maximum-pool-size=40
spring.datasource.hikari.minimum-idle=10

# Falla rápido: no dejes que diez mil hilos esperen treinta segundos.
spring.datasource.hikari.connection-timeout=3000

spring.datasource.hikari.leak-detection-threshold=20000

# 1 · synchronized alrededor de E/S: la causa nº 1 de pinning en Java 21–23.
#     Ignóralo por completo si estás en Java 24+ (JEP 491).
grep -rn "synchronized" --include="*.java" src/main/java

# 2 · ThreadLocal: cada uno de estos se convierte en N copias.
grep -rn "ThreadLocal\|InheritableThreadLocal" --include="*.java" src/main/java

# 3 · Beans de executor explícitos: el flag NO los toca.
grep -rn "ThreadPoolTaskExecutor\|newFixedThreadPool\|newCachedThreadPool" \
     --include="*.java" src/main/java

# 4 · parallelStream sobre trabajo bloqueante: un bug preexistente que ahora notarás.
grep -rn "parallelStream()" --include="*.java" src/main/java

# 5 · Librerías nativas: harán pinning sea cual sea la versión de Java.
grep -rn "System.loadLibrary\|native " --include="*.java" src/main/java

# Java 21–23: traza de pinning
java -Djdk.tracePinnedThreads=full -jar app.jar

# Cualquier versión: JFR es la respuesta apta para producción
java -XX:StartFlightRecording=duration=300s,filename=loom.jfr,settings=profile -jar app.jar

jfr print --events jdk.VirtualThreadPinned loom.jfr | head -100

/**
 * Un bulkhead por recurso de destino. Esta clase sustituye la protección
 * accidental que el thread pool proporcionaba gratis.
 */
@Component
public class BulkheadsDestino {

    private final Map<String, Semaphore> permisos = Map.of(
        "bd",       new Semaphore(40),    // = maximum-pool-size de HikariCP
        "pagos",    new Semaphore(100),   // = límite contractual del proveedor
        "busqueda", new Semaphore(200),   // = lo que tolera Elasticsearch
        "llm",      new Semaphore(20)     // = cuota del proveedor de modelos
    );

    public <T> T llamar(String recurso, Duration timeout, Callable<T> tarea) throws Exception {

        Semaphore semaforo = permisos.get(recurso);

        // tryAcquire CON timeout, nunca acquire() a secas: bajo sobrecarga
        // quieres un 503 rápido, no cincuenta mil hilos esperando un permiso.
        if (!semaforo.tryAcquire(timeout.toMillis(), TimeUnit.MILLISECONDS)) {
            throw new RecursoAgotadoException(recurso);   // → HTTP 503
        }

        try {
            return tarea.call();
        } finally {
            semaforo.release();
        }
    }
}

// Haz que el cambio se controle en tiempo de ejecución
// para que el rollback sea inmediato.

@Configuration
class ExecutorConfig {

    @Bean
    AsyncTaskExecutor applicationTaskExecutor(
            @Value("${app.virtual-threads.enabled:false}") boolean virtual) {

        if (virtual) {
            SimpleAsyncTaskExecutor executor = new SimpleAsyncTaskExecutor("vt-");
            executor.setVirtualThreads(true);
            executor.setConcurrencyLimit(1_000);
            return executor;
        }

        ThreadPoolTaskExecutor legado = new ThreadPoolTaskExecutor();
        legado.setCorePoolSize(50);
        legado.setMaxPoolSize(200);
        legado.setQueueCapacity(500);
        legado.setThreadNamePrefix("pool-");
        legado.initialize();
        return legado;
    }
}

// Absurdo: los pools existen para reutilizar cosas caras. Estas son baratas.
ExecutorService mal = Executors.newFixedThreadPool(100, Thread.ofVirtual().factory());

// Correcto
ExecutorService bien = Executors.newVirtualThreadPerTaskExecutor();

// Reintroduce el techo que acabas de quitar
ExecutorService mal = Executors.newFixedThreadPool(50);

// Hilos ilimitados, acceso limitado a lo que de verdad es escaso
Semaphore permisosBd = new Semaphore(40);

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    tareas.forEach(executor::submit);
}   // close() espera. Sin él, son daemon y mueren al salir la JVM.

// Con un pool, el pool acotaba tu radio de explosión.
// Ahora no lo hace nada: los timeouts dejan de ser opcionales.

HttpClient client = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(2))
        .build();

HttpRequest request = HttpRequest.newBuilder(uri)
        .timeout(Duration.ofSeconds(5))     // timeout por petición
        .build();

// Has pagado el coste de la migración y te has quedado el techo de 200 hilos.
// Todos los inconvenientes, ninguna ventaja.

Executors.newFixedThreadPool(200, Thread.ofVirtual().factory());

// 1.000.000 de hilos × buffer de 8 KB = 8 GB. Adiós.

private static final ThreadLocal<byte[]> BUFFER =
    ThreadLocal.withInitial(() -> new byte[8192]);

// 10.000 virtual threads compitiendo por 8 carriers, sin expropiación
// y con peor localidad de caché que un pool dimensionado.

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    imagenes.forEach(img -> executor.submit(() -> redimensionar(img)));
}

public static void main(String[] args) {
    Thread.startVirtualThread(() -> trabajoCritico());
}   // La JVM termina al instante. El trabajo nunca se ejecutó.

// 100.000 hilos → 100.000 series temporales → tu Prometheus se cae.

Metrics.counter("peticiones", "thread", Thread.currentThread().getName())
       .increment();

// 1.000 peticiones × 100 elementos = 100.000 llamadas concurrentes
// a una API externa. La multiplicación es invisible en una revisión
// de código y letal en producción.

try (var externo = Executors.newVirtualThreadPerTaskExecutor()) {

    peticiones.forEach(p -> externo.submit(() -> {

        try (var interno = Executors.newVirtualThreadPerTaskExecutor()) {
            p.elementos().forEach(e -> interno.submit(() -> apiSocio.llamar(e)));
        }

    }));
}

@Service
class CheckoutService {

    @Autowired @Qualifier("checkoutExecutor")
    private ThreadPoolTaskExecutor executor;   // core 50, max 200, cola 1.000, AbortPolicy

    public ResultadoCompra comprar(SolicitudCompra solicitud) {

        CompletableFuture<Cliente> cliente = CompletableFuture.supplyAsync(
                () -> clienteClient.buscar(solicitud.clienteId()), executor);

        CompletableFuture<Stock> stock = CompletableFuture.supplyAsync(
                () -> inventarioClient.reservar(solicitud.lineas()), executor);

        CompletableFuture<Promocion> promocion = CompletableFuture.supplyAsync(
                () -> promocionClient.mejorPara(solicitud), executor);

        return CompletableFuture.allOf(cliente, stock, promocion)
            .thenCompose(v -> {
                Pedido pedido = pedidoFactory.crear(
                        cliente.join(), stock.join(), promocion.join());

                return CompletableFuture
                    .supplyAsync(() -> pagoClient.cobrar(pedido), executor)
                    .thenCombine(
                        CompletableFuture.supplyAsync(
                                () -> envioClient.cotizar(pedido), executor),
                        (pago, envio) -> pedidoRepository.guardar(pedido, pago, envio))
                    .thenApply(ResultadoCompra::de);
            })
            .exceptionally(this::mapearFallo)
            .join();
    }
}

@Service
class CheckoutService {

    // Un bulkhead por destino, dimensionado a la capacidad real de cada uno.
    private static final Semaphore PERMISOS_PAGO       = new Semaphore(150);  // contrato
    private static final Semaphore PERMISOS_INVENTARIO = new Semaphore(400);
    private static final Semaphore PERMISOS_BD         = new Semaphore(40);   // = Hikari

    public ResultadoCompra comprar(SolicitudCompra solicitud) throws Exception {

        try (var scope = Executors.newVirtualThreadPerTaskExecutor()) {

            Future<Cliente>   cliente   = scope.submit(
                    () -> clienteClient.buscar(solicitud.clienteId()));

            Future<Stock>     stock     = scope.submit(() -> acotado(PERMISOS_INVENTARIO,
                    () -> inventarioClient.reservar(solicitud.lineas())));

            Future<Promocion> promocion = scope.submit(
                    () -> promocionClient.mejorPara(solicitud));

            Pedido pedido = pedidoFactory.crear(
                    cliente.get(), stock.get(), promocion.get());

            Future<Pago>  pago  = scope.submit(() -> acotado(PERMISOS_PAGO,
                    () -> pagoClient.cobrar(pedido)));

            Future<Envio> envio = scope.submit(() -> envioClient.cotizar(pedido));

            // Se resuelven las dos llamadas de red ANTES de pedir el permiso
            // de base de datos. Adquirirlo primero y esperar dentro mantendría
            // ocupada una de las 40 conexiones durante los 250 ms de la
            // pasarela de pago: es la forma más rápida de agotar el pool sin
            // que ninguna métrica de base de datos lo explique.
            Pago  pagoRealizado = pago.get();
            Envio envioCotizado = envio.get();

            return acotado(PERMISOS_BD, () -> ResultadoCompra.de(
                    pedidoRepository.guardar(pedido, pagoRealizado, envioCotizado)));
        }
    }

    private static <T> T acotado(Semaphore permisos, Callable<T> tarea) throws Exception {
        if (!permisos.tryAcquire(2, TimeUnit.SECONDS)) {
            throw new RecursoAgotadoException();      // → 503 rápido
        }
        try { return tarea.call(); } finally { permisos.release(); }
    }
}

spring.threads.virtual.enabled=true

server.tomcat.max-connections=8000

spring.datasource.hikari.maximum-pool-size=40
spring.datasource.hikari.connection-timeout=2000

// CompletableFuture: composición asíncrona
CompletableFuture<Cuadro> cuadro =
    CompletableFuture.supplyAsync(() -> usuarioService.buscar(id), executor)
        .thenCombine(
            CompletableFuture.supplyAsync(() -> pedidoService.buscarDe(id), executor),
            (usuario, pedidos) -> new Parcial(usuario, pedidos))
        .thenCompose(parcial ->
            CompletableFuture.supplyAsync(() -> riesgoService.calcular(id), executor)
                .thenApply(riesgo -> new Cuadro(parcial, riesgo)))
        .exceptionally(this::respaldo);


// Virtual threads: misma concurrencia, forma secuencial
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {

    Future<Usuario> usuario = executor.submit(() -> usuarioService.buscar(id));
    Future<Pedidos> pedidos = executor.submit(() -> pedidoService.buscarDe(id));
    Future<Riesgo>  riesgo  = executor.submit(() -> riesgoService.calcular(id));

    return new Cuadro(usuario.get(), pedidos.get(), riesgo.get());

} catch (Exception e) {
    return respaldo(e);
}

// Heurística barata para clasificar una carga: ratio de espera alto ⇒ IO bound.
//
// IMPORTANTE: ejecútala sobre un PLATFORM THREAD. ThreadMXBean no está
// pensado para virtual threads; desde uno, getCurrentThreadCpuTime() mide
// el carrier y el resultado no significa lo que parece. Mídelo antes de
// migrar, que además es cuando necesitas la respuesta.

ThreadMXBean mx = ManagementFactory.getThreadMXBean();

if (!mx.isCurrentThreadCpuTimeSupported() || Thread.currentThread().isVirtual()) {
    log.warn("Medición de CPU por hilo no disponible en este contexto");
    return;
}

long inicio    = System.nanoTime();
long cpuInicio = mx.getCurrentThreadCpuTime();

hacerElTrabajo();

double relojMs = (System.nanoTime() - inicio) / 1e6;
double cpuMs   = (mx.getCurrentThreadCpuTime() - cpuInicio) / 1e6;

log.info("reloj={}ms cpu={}ms ratio={}", relojMs, cpuMs, cpuMs / relojMs);

// ratio < 0,1  → IO bound  → virtual threads
// ratio > 0,8  → CPU bound → pool de platform dimensionado