Creación de hilos virtuales
Thread.ofVirtual y ejecutores
Creación de hilos virtuales es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.
Formas de crear hilos virtuales
Java ofrece varios puntos de entrada para crear hilos virtuales. Los dos más importantes son el builder Thread.ofVirtual() y la factory Executors.newVirtualThreadPerTaskExecutor().
En esta lección se explica cada uno.
El builder: start
Thread.ofVirtual() devuelve un builder. Al llamar a .start(runnable), se crea e inicia inmediatamente el hilo.
public class Main {
public static void main(String[] args) throws InterruptedException {
Thread t = Thread.ofVirtual().start(() ->
System.out.println("Started directly"));
t.join();
}
}El builder: unstarted
Use .unstarted(runnable) cuando quiera configurar el hilo e iniciarlo más tarde.
public class Main {
public static void main(String[] args) throws InterruptedException {
Thread t = Thread.ofVirtual().unstarted(() ->
System.out.println("Started later"));
System.out.println("Before start, alive? " + t.isAlive());
t.start();
t.join();
}
}Una factory reutilizable
El builder puede producir un ThreadFactory mediante .factory(). Cada llamada a newThread genera un nuevo hilo virtual.
import java.util.concurrent.ThreadFactory;
public class Main {
public static void main(String[] args) throws InterruptedException {
ThreadFactory factory = Thread.ofVirtual().name("job-", 0).factory();
Thread a = factory.newThread(() ->
System.out.println(Thread.currentThread().getName()));
Thread b = factory.newThread(() ->
System.out.println(Thread.currentThread().getName()));
a.start(); b.start();
a.join(); b.join();
}
}El método de conveniencia
Thread.startVirtualThread(runnable) es una forma abreviada de crear e iniciar un hilo virtual sin nombre en una sola llamada.
public class Main {
public static void main(String[] args) throws InterruptedException {
Thread t = Thread.startVirtualThread(() ->
System.out.println("One-liner virtual thread"));
t.join();
}
}El enfoque con un executor
Para el código orientado a tareas, prefiera Executors.newVirtualThreadPerTaskExecutor(). Crea un nuevo hilo virtual para cada tarea enviada.
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main {
public static void main(String[] args) {
try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
exec.submit(() -> System.out.println("task one"));
exec.submit(() -> System.out.println("task two"));
}
System.out.println("All tasks submitted and completed");
}
}Por qué usar try-with-resources
Desde Java 19, ExecutorService implementa AutoCloseable. Al cerrarlo dentro de un bloque try-with-resources, se espera a que finalicen todas las tareas enviadas.
Esto permite realizar un apagado limpio y estructurado sin llamadas manuales a shutdown y awaitTermination.
Envío de muchas tareas
El executor por tarea gestiona sin esfuerzo una gran cantidad de tareas. Cada tarea obtiene su propio hilo virtual.
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
public class Main {
public static void main(String[] args) {
AtomicInteger sum = new AtomicInteger();
try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
for (int i = 1; i <= 1000; i++) {
final int n = i;
exec.submit(() -> sum.addAndGet(n));
}
}
System.out.println("Sum 1..1000 = " + sum.get());
}
}Recopilar resultados con Future
submit devuelve un Future, por lo que puede recopilar valores devueltos igual que con cualquier executor.
import java.util.concurrent.*;
public class Main {
public static void main(String[] args) throws Exception {
try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
Future<Integer> f = exec.submit(() -> 6 * 7);
System.out.println("Result: " + f.get());
}
}
}Builder frente a executor
Elija según la intención:
- Builder / startVirtualThread para hilos puntuales o nombres personalizados
- newVirtualThreadPerTaskExecutor para enviar colecciones de tareas y recopilar resultados
Ambos crean un hilo virtual por unidad de trabajo, que es exactamente lo que necesita.
Nunca almacene en caché un executor virtual
No reutilice un único executor de hilos virtuales como si fuera un pool fijo de trabajadores. El executor se puede reutilizar, pero recuerde que cada tarea genera un hilo completamente nuevo.
La cuestión es que no se agrupan los hilos en un pool; solo se facilita el envío de tareas.
Comprobación rápida
Elija la mejor forma de ejecutar un lote grande de tareas, cada una en su propio hilo virtual.
Resumen
Ahora sabe cómo crear hilos virtuales:
Thread.ofVirtual().start(...)y.unstarted(...)- La llamada de una sola línea
Thread.startVirtualThread(...) .factory()para obtener unThreadFactoryreutilizableExecutors.newVirtualThreadPerTaskExecutor()con try-with-resources
A continuación: elegir entre hilos de plataforma y hilos virtuales.
Preguntas frecuentes
¿La lección «Creación de hilos virtuales» es gratis?
Sí — el texto completo de «Creación de hilos virtuales» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Creación de hilos virtuales»?
Thread.ofVirtual y ejecutores Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Java Academy?
No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Creación de hilos virtuales»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Java Academy?
Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Qué son los hilos virtuales
- Creación de hilos virtuales
- Hilos de plataforma frente a hilos virtuales
- Errores: pinning y ThreadLocals