Java

Tutorial Java: Virtual Threads (Project Loom)

Aprende a usar virtual threads en Java 21 con Project Loom para mejorar la concurrencia y escalabilidad en tus aplicaciones.

Aprende Java y certifícate

Concepto y ventajas de los threads virtuales

Los threads virtuales representan una de las innovaciones más significativas en la plataforma Java, introducidos oficialmente en Java 21 como parte del Proyecto Loom. A diferencia de los threads tradicionales (ahora llamados threads de plataforma), que están vinculados directamente a los threads del sistema operativo, los threads virtuales son implementaciones ligeras gestionadas por la JVM.

Un thread virtual es esencialmente una abstracción de alto nivel que no mantiene una relación uno a uno con los threads del sistema operativo. En su lugar, muchos threads virtuales pueden ser multiplexados sobre un número menor de threads de plataforma, similar a como las fibras o corrutinas funcionan en otros lenguajes de programación.

Arquitectura de los threads virtuales

La arquitectura de los threads virtuales se basa en un modelo de programación cooperativa donde:

  • La JVM administra un pool de carriers (threads de plataforma)
  • Los threads virtuales se asignan a estos carriers cuando necesitan ejecutarse
  • Cuando un thread virtual realiza una operación bloqueante (como I/O), la JVM lo desmonta del carrier
  • El carrier queda libre para ejecutar otro thread virtual
  • Cuando la operación bloqueante se completa, el thread virtual se remonta en un carrier disponible
// Representación conceptual de la arquitectura (no es código ejecutable)
VirtualThreads (miles/millones) → Scheduler JVM → Carriers (decenas) → CPU Cores

Ventajas principales

Los threads virtuales ofrecen numerosas ventajas que transforman la forma en que desarrollamos aplicaciones concurrentes en Java:

  • Escalabilidad masiva: Puedes crear millones de threads virtuales en una sola JVM, algo imposible con threads de plataforma.
// Crear un millón de threads virtuales es viable
List<Thread> threads = new ArrayList<>();
for (int i = 0; i < 1_000_000; i++) {
    Thread vt = Thread.ofVirtual().start(() -> {
        // Tarea a ejecutar
        try {
            Thread.sleep(1000); // Operación bloqueante
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    });
    threads.add(vt);
}
  • Eficiencia en memoria: Cada thread virtual consume significativamente menos memoria que un thread de plataforma.

  • Modelo de programación familiar: Utilizas la misma API de Thread que ya conoces, sin necesidad de aprender nuevos paradigmas como la programación reactiva.

// El mismo código funciona tanto para threads virtuales como de plataforma
Runnable task = () -> System.out.println("Ejecutando en: " + Thread.currentThread());
Thread.ofVirtual().start(task);  // Thread virtual
Thread.ofPlatform().start(task); // Thread de plataforma
  • Bloqueo sin penalización: Las operaciones bloqueantes (como I/O o sleep()) no bloquean el thread de plataforma subyacente, permitiendo un uso más eficiente de los recursos.

  • Depuración simplificada: Los threads virtuales mantienen su propia pila de llamadas, facilitando la depuración en comparación con modelos asíncronos basados en callbacks.

  • Rendimiento mejorado en aplicaciones I/O-bound: Las aplicaciones que realizan muchas operaciones de I/O (como servidores web o microservicios) se benefician enormemente al poder manejar más conexiones concurrentes.

Casos de uso ideales

Los threads virtuales brillan especialmente en ciertos escenarios:

  • Servidores HTTP con muchas conexiones concurrentes: Cada conexión puede tener su propio thread virtual.

  • Microservicios que necesitan realizar múltiples llamadas a APIs externas.

  • Aplicaciones de procesamiento de datos que requieren paralelismo a gran escala.

  • Sistemas de mensajería que manejan miles de conexiones simultáneas.

// Ejemplo conceptual de servidor HTTP con threads virtuales
ServerSocket serverSocket = new ServerSocket(8080);
while (true) {
    Socket socket = serverSocket.accept();
    Thread.ofVirtual().start(() -> {
        try (socket) {
            handleRequest(socket); // Cada conexión tiene su propio thread virtual
        } catch (IOException e) {
            e.printStackTrace();
        }
    });
}

Limitaciones a considerar

A pesar de sus ventajas, es importante entender algunas limitaciones:

  • No son adecuados para tareas CPU-bound intensivas, donde los threads de plataforma siguen siendo más eficientes.

  • No se pueden usar con métodos nativos sincronizados (synchronized native).

  • No están diseñados para reemplazar completamente los modelos de programación asíncrona en todos los casos.

  • Las operaciones de sincronización extensivas (como muchos synchronized anidados) pueden reducir sus beneficios.

Los threads virtuales representan un cambio de paradigma en la concurrencia de Java, permitiendo escribir código concurrente de manera sencilla y directa, sin sacrificar la escalabilidad. Esta tecnología permite que Java compita efectivamente con lenguajes y plataformas que ya ofrecían modelos de concurrencia ligeros, como Go con sus goroutines o Node.js con su modelo basado en eventos.

Creación y uso de virtual threads

Los threads virtuales en Java ofrecen una forma sencilla y eficiente de trabajar con concurrencia. Su API está diseñada para ser familiar para los desarrolladores de Java, manteniendo la compatibilidad con el modelo de programación de threads existente mientras aprovecha las ventajas de esta nueva tecnología.

Formas de crear threads virtuales

Existen varias maneras de crear y trabajar con threads virtuales, cada una adaptada a diferentes necesidades:

  • Creación directa: Usando los métodos factory de la clase Thread
// Creación y ejecución de un thread virtual
Thread vThread = Thread.ofVirtual().start(() -> {
    System.out.println("Ejecutando en thread virtual: " + Thread.currentThread().getName());
});

// Esperar a que termine
vThread.join();
  • Creación sin inicio inmediato: Si necesitas configurar el thread antes de iniciarlo
// Crear sin iniciar
Thread vThread = Thread.ofVirtual().unstarted(() -> {
    System.out.println("Este thread se inicia más tarde");
});

// Configuración adicional
vThread.setName("MiThreadVirtual");

// Iniciar cuando sea necesario
vThread.start();
  • Creación con nombre personalizado: Para facilitar la depuración
Thread vThread = Thread.ofVirtual().name("Procesador-1").start(() -> {
    System.out.println("Thread con nombre personalizado: " + Thread.currentThread().getName());
});

Ejecutores de threads virtuales

Para escenarios donde necesitas gestionar múltiples tareas concurrentes, Java proporciona ejecutores específicos para threads virtuales:

// Crear un ExecutorService basado en threads virtuales
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    // Enviar múltiples tareas
    IntStream.range(0, 10_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(Duration.ofMillis(100));
            return i;
        });
    });
    // El executor se cerrará automáticamente al salir del bloque try-with-resources
}

Este ejecutor crea un nuevo thread virtual para cada tarea enviada, lo que es extremadamente eficiente con los threads virtuales. A diferencia de los pools de threads tradicionales, no hay necesidad de limitar el número de threads, ya que los threads virtuales son recursos ligeros.

Patrones comunes de uso

Paralelización de tareas independientes

Uno de los casos de uso más comunes es ejecutar múltiples tareas independientes en paralelo:

List<String> urls = List.of(
    "https://example.com/api/resource1",
    "https://example.com/api/resource2",
    "https://example.com/api/resource3"
);

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    // Convertir cada URL en una tarea y ejecutarlas en paralelo
    List<Future<String>> futures = urls.stream()
        .map(url -> executor.submit(() -> fetchData(url)))
        .toList();
    
    // Recopilar resultados
    List<String> results = new ArrayList<>();
    for (Future<String> future : futures) {
        results.add(future.get()); // Esperar cada resultado
    }
}

// Método que simula una petición HTTP
private static String fetchData(String url) throws Exception {
    // Simulamos latencia de red
    Thread.sleep(Duration.ofMillis((long) (Math.random() * 1000)));
    return "Datos de " + url;
}

Procesamiento de flujos de datos

Los threads virtuales son ideales para procesar flujos de datos donde cada elemento requiere operaciones potencialmente bloqueantes:

List<Customer> customers = getCustomers(); // Obtener lista de clientes

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    // Procesar cada cliente en su propio thread virtual
    List<Future<CustomerReport>> futures = customers.stream()
        .map(customer -> executor.submit(() -> generateReport(customer)))
        .toList();
    
    // Recopilar todos los informes
    List<CustomerReport> reports = futures.stream()
        .map(future -> {
            try {
                return future.get();
            } catch (Exception e) {
                return new CustomerReport("Error: " + e.getMessage());
            }
        })
        .toList();
}

// Método que simula una operación bloqueante
private static CustomerReport generateReport(Customer customer) throws Exception {
    // Simulamos acceso a base de datos o servicio externo
    Thread.sleep(Duration.ofMillis(500));
    return new CustomerReport("Informe para " + customer.getName());
}

Estructuración con scope y fork-join

Java 21 introduce el concepto de structured concurrency a través de la API StructuredTaskScope, que complementa perfectamente los threads virtuales:

// Importaciones necesarias
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.Future;

// Método que realiza dos operaciones en paralelo y combina sus resultados
public static OrderResult processOrder(String orderId) throws Exception {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
        // Lanzar dos subtareas en paralelo
        Future<CustomerData> customerFuture = scope.fork(() -> fetchCustomerData(orderId));
        Future<InventoryData> inventoryFuture = scope.fork(() -> checkInventory(orderId));
        
        // Esperar a que ambas tareas terminen (o una falle)
        scope.join();
        // Propagar cualquier excepción
        scope.throwIfFailed();
        
        // Combinar resultados
        return createOrderResult(customerFuture.resultNow(), inventoryFuture.resultNow());
    }
}

Este patrón garantiza que todas las subtareas se completen (o cancelen) antes de que el método principal retorne, evitando fugas de recursos y simplificando el manejo de errores.

Consideraciones prácticas

Al trabajar con threads virtuales, hay algunas consideraciones importantes:

  • Monitorización: Para monitorizar threads virtuales, usa JDK Flight Recorder y JFR Events:
// Habilitar eventos JFR para threads virtuales
-Djdk.tracePinnedThreads=full
  • Pinning: Evita operaciones que puedan causar "pinning" (bloqueo del carrier thread):
// Evitar sincronización prolongada en código que usa threads virtuales
synchronized (lock) {
    // Operaciones rápidas OK
    // Evitar operaciones bloqueantes o largas aquí
}
  • Compatibilidad con bibliotecas: Asegúrate de que las bibliotecas que utilizas sean compatibles con threads virtuales, especialmente aquellas que realizan operaciones bloqueantes.

  • Depuración: Usa nombres descriptivos para tus threads virtuales para facilitar la depuración:

Thread.ofVirtual()
    .name("worker-", 1) // Creará threads con nombres worker-1, worker-2, etc.
    .start(runnable);

Migración desde threads tradicionales

Si estás migrando código existente que usa threads de plataforma, estos patrones te ayudarán:

  • Reemplazar pools de threads fijos:
// Antes: Pool fijo de threads de plataforma
ExecutorService executorOld = Executors.newFixedThreadPool(100);

// Después: Executor de threads virtuales sin límite práctico
ExecutorService executorNew = Executors.newVirtualThreadPerTaskExecutor();
  • Convertir código secuencial a paralelo:
// Antes: Procesamiento secuencial
for (Request request : requests) {
    processRequest(request);
}

// Después: Procesamiento paralelo con threads virtuales
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    List<Future<?>> futures = requests.stream()
        .map(request -> executor.submit(() -> processRequest(request)))
        .toList();
    
    // Esperar a que todas las tareas terminen
    for (Future<?> future : futures) {
        future.get();
    }
}

Los threads virtuales permiten escribir código concurrente de forma directa y legible, sin necesidad de recurrir a complejos modelos asíncronos basados en callbacks o programación reactiva, especialmente para aplicaciones con operaciones de I/O intensivas.

CONSTRUYE TU CARRERA EN IA Y PROGRAMACIÓN SOFTWARE

Accede a +1000 lecciones y cursos con certificado. Mejora tu portfolio con certificados de superación para tu CV.

30 % DE DESCUENTO

Plan mensual

19.00 /mes

13.30 € /mes

Precio normal mensual: 19 €
63 % DE DESCUENTO

Plan anual

10.00 /mes

7.00 € /mes

Ahorras 144 € al año
Precio normal anual: 120 €
Aprende Java online

Ejercicios de esta lección Virtual Threads (Project Loom)

Evalúa tus conocimientos de esta lección Virtual Threads (Project Loom) con nuestros retos de programación de tipo Test, Puzzle, Código y Proyecto con VSCode, guiados por IA.

Streams: match

Test

Gestión de errores y excepciones

Código

CRUD en Java de modelo Customer sobre un ArrayList

Proyecto

Clases abstractas

Test

Listas

Código

Métodos de la clase String

Código

Streams: reduce()

Test

API java.nio 2

Puzzle

Polimorfismo

Código

Pattern Matching

Código

Streams: flatMap()

Test

Llamada y sobrecarga de funciones

Puzzle

Métodos referenciados

Test

Métodos de la clase String

Código

Representación de Fecha

Puzzle

Operadores lógicos

Test

Inferencia de tipos con var

Código

Tipos de datos

Código

Estructuras de iteración

Puzzle

Streams: forEach()

Test

Objetos

Puzzle

Funciones lambda

Test

Uso de Scanner

Puzzle

Tipos de variables

Puzzle

Streams: collect()

Puzzle

Operadores aritméticos

Puzzle

Arrays y matrices

Código

Clases y objetos

Código

Interfaz funcional Consumer

Test

CRUD en Java de modelo Customer sobre un HashMap

Proyecto

Interfaces

Código

Enumeraciones Enums

Código

API Optional

Test

Interfaz funcional Function

Test

Encapsulación

Test

Interfaces

Código

Uso de API Optional

Puzzle

Representación de Hora

Test

Herencia básica

Test

Clases y objetos

Código

Interfaz funcional Supplier

Puzzle

HashMap

Puzzle

Sobrecarga de métodos

Test

Polimorfismo de tiempo de ejecución

Puzzle

OOP en Java

Proyecto

Sobrecarga de métodos

Código

CRUD de productos en Java

Proyecto

Clases sealed

Código

Creación de Streams

Test

Records

Código

Encapsulación

Código

Streams: min max

Puzzle

Herencia

Código

Métodos avanzados de la clase String

Puzzle

Funciones

Código

Polimorfismo de tiempo de compilación

Test

Reto sintaxis Java

Proyecto

Conjuntos

Código

Estructuras de control

Código

Recursión

Código

Excepciones

Puzzle

Herencia avanzada

Puzzle

Estructuras de selección

Test

Uso de interfaces

Test

Operadores

Código

Variables

Código

HashSet

Test

Objeto Scanner

Test

Streams: filter()

Puzzle

Operaciones de Streams

Puzzle

Interfaz funcional Predicate

Puzzle

Streams: sorted()

Test

Configuración de entorno

Test

Uso de variables

Test

Clases

Test

Streams: distinct()

Puzzle

Streams: count()

Test

ArrayList

Test

Mapas

Código

Datos de referencia

Test

Interfaces funcionales

Puzzle

Métodos básicos de la clase String

Test

Tipos de datos

Código

Clases abstractas

Código

Instalación

Test

Funciones

Código

Excepciones

Código

Estructuras de control

Código

Herencia de clases

Código

La clase Scanner

Código

Generics

Código

Streams: map()

Puzzle

Funciones y encapsulamiento

Test

Todas las lecciones de Java

Accede a todas las lecciones de Java y aprende con ejemplos prácticos de código y ejercicios de programación con IDE web sin instalar nada.

Instalación De Java

Introducción Y Entorno

Configuración De Entorno Java

Introducción Y Entorno

Tipos De Datos

Sintaxis

Variables

Sintaxis

Operadores

Sintaxis

Estructuras De Control

Sintaxis

Funciones

Sintaxis

Recursión

Sintaxis

Arrays Y Matrices

Sintaxis

Excepciones

Programación Orientada A Objetos

Clases Y Objetos

Programación Orientada A Objetos

Encapsulación

Programación Orientada A Objetos

Herencia

Programación Orientada A Objetos

Clases Abstractas

Programación Orientada A Objetos

Interfaces

Programación Orientada A Objetos

Sobrecarga De Métodos

Programación Orientada A Objetos

Polimorfismo

Programación Orientada A Objetos

La Clase Scanner

Programación Orientada A Objetos

Métodos De La Clase String

Programación Orientada A Objetos

Excepciones

Programación Orientada A Objetos

Records

Programación Orientada A Objetos

Pattern Matching

Programación Orientada A Objetos

Inferencia De Tipos Con Var

Programación Orientada A Objetos

Enumeraciones Enums

Programación Orientada A Objetos

Generics

Programación Orientada A Objetos

Clases Sealed

Programación Orientada A Objetos

Listas

Framework Collections

Conjuntos

Framework Collections

Mapas

Framework Collections

Funciones Lambda

Programación Funcional

Interfaz Funcional Consumer

Programación Funcional

Interfaz Funcional Predicate

Programación Funcional

Interfaz Funcional Supplier

Programación Funcional

Interfaz Funcional Function

Programación Funcional

Métodos Referenciados

Programación Funcional

Creación De Streams

Programación Funcional

Operaciones Intermedias Con Streams: Map()

Programación Funcional

Operaciones Intermedias Con Streams: Filter()

Programación Funcional

Operaciones Intermedias Con Streams: Distinct()

Programación Funcional

Operaciones Finales Con Streams: Collect()

Programación Funcional

Operaciones Finales Con Streams: Min Max

Programación Funcional

Operaciones Intermedias Con Streams: Flatmap()

Programación Funcional

Operaciones Intermedias Con Streams: Sorted()

Programación Funcional

Operaciones Finales Con Streams: Reduce()

Programación Funcional

Operaciones Finales Con Streams: Foreach()

Programación Funcional

Operaciones Finales Con Streams: Count()

Programación Funcional

Operaciones Finales Con Streams: Match

Programación Funcional

Api Optional

Programación Funcional

Transformación

Programación Funcional

Reducción Y Acumulación

Programación Funcional

Mapeo

Programación Funcional

Streams Paralelos

Programación Funcional

Agrupación Y Partición

Programación Funcional

Filtrado Y Búsqueda

Programación Funcional

Api Java.nio 2

Entrada Y Salida Io

Fundamentos De Io

Entrada Y Salida Io

Leer Y Escribir Archivos

Entrada Y Salida Io

Httpclient Moderno

Entrada Y Salida Io

Clases De Nio2

Entrada Y Salida Io

Api Java.time

Api Java.time

Localtime

Api Java.time

Localdatetime

Api Java.time

Localdate

Api Java.time

Executorservice

Concurrencia

Virtual Threads (Project Loom)

Concurrencia

Future Y Completablefuture

Concurrencia

Spring Framework

Frameworks Para Java

Micronaut

Frameworks Para Java

Maven

Frameworks Para Java

Gradle

Frameworks Para Java

Lombok Para Java

Frameworks Para Java

Quarkus

Frameworks Para Java

Ecosistema Jakarta Ee De Java

Frameworks Para Java

Introducción A Junit 5

Testing

Accede GRATIS a Java y certifícate

Certificados de superación de Java

Supera todos los ejercicios de programación del curso de Java y obtén certificados de superación para mejorar tu currículum y tu empleabilidad.

En esta lección

Objetivos de aprendizaje de esta lección

  • Comprender el concepto y la arquitectura de los threads virtuales en Java.
  • Identificar las ventajas y limitaciones de los threads virtuales frente a los threads tradicionales.
  • Aprender a crear y gestionar threads virtuales mediante la API de Java.
  • Aplicar patrones comunes de concurrencia con threads virtuales y ejecutores especializados.
  • Conocer buenas prácticas y consideraciones para migrar código y monitorizar threads virtuales.