🚀 Comparación de Hilos Tradicionales vs Hilos Virtuales en Java (Project Loom)

Este proyecto muestra cómo Spring Boot puede ejecutar tareas concurrentes utilizando hilos tradicionales y hilos virtuales de Project Loom en Java 21.

📌 ¿Qué aprenderás?

✅ Diferencia entre hilos tradicionales y virtuales
✅ Cómo mejorar el rendimiento en aplicaciones concurrentes
✅ Uso de Spring Boot para manejar tareas con hilos
✅ Comparación del tiempo de ejecución de cada método

---

📚 ¿Qué es Project Loom?

💡 Project Loom es una nueva característica de Java 21 que introduce los hilos virtuales (Virtual Threads).
A diferencia de los hilos tradicionales (Thread), los hilos virtuales no dependen del sistema operativo y son administrados por la JVM, lo que los hace más eficientes y escalables.

🆚 Diferencias Clave

🔹 Característica	🔵 Hilos Tradicionales	🟢 Hilos Virtuales
Gestión	Sistema operativo 🖥️	JVM 🏗️
Peso	Pesados, usan memoria extra	Ligeros y eficientes
Escalabilidad	Limitados (máximo cientos)	Millones de hilos 🚀
Bloqueos	Sí, pueden bloquear CPU	No bloquean, esperan 💤
Ideal para...	Aplicaciones pequeñas	Aplicaciones masivas ⚡

---

⚙️ Instalación y Ejecución

📌 Requisitos previos

✔️ Java 21+ instalado
✔️ Spring Boot 3+
✔️ Maven instalado

📌 Clonar el repositorio

git clone https://github.com/FirstOnDie/loom-processing.git
cd loom-processing

📌 Ejecutar el proyecto

mvn spring-boot:run

---

🛠️ Arquitectura del Proyecto

📌 TaskService.java → Contiene la lógica para procesar tareas usando hilos tradicionales y hilos virtuales.
📌 TaskController.java → Exposición de endpoints REST para ejecutar cada tipo de tarea.

🌍 Endpoints disponibles

📌 Ejecutar con hilos tradicionales

GET http://localhost:8080/tasks/traditional

📌 Ejecutar con hilos virtuales

GET http://localhost:8080/tasks/virtual

---

💻 Código del Servicio

🟢 TaskService.java

@Service
public class TaskService {

    public String processWithTraditionalThreads() {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        long start = System.currentTimeMillis();

        List<Future<String>> futures = new ArrayList<>();

        for (int i = 0; i < 10_000; i++) { // 🔥 10,000 tareas
            futures.add(executor.submit(() -> {
                simulateHeavyTask();
                return "Procesado con hilos tradicionales";
            }));
        }

        for (Future<String> future : futures) {
            try {
                future.get(); // 🔥 Esperamos cada resultado
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        long end = System.currentTimeMillis();
        System.out.println("⏳ Tiempo con hilos tradicionales: " + (end - start) + " ms");

        executor.shutdown();
        return "Finalizado con hilos tradicionales";
    }

    public String processWithVirtualThreads() {
        long start = System.currentTimeMillis();

        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<String>> futures = new ArrayList<>();

            for (int i = 0; i < 10_000; i++) { // 🔥 10,000 tareas
                futures.add(executor.submit(() -> {
                    simulateHeavyTask();
                    return "Procesado con hilos virtuales";
                }));
            }

            for (Future<String> future : futures) {
                try {
                    future.get();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            long end = System.currentTimeMillis();
            System.out.println("🚀 Tiempo con hilos virtuales: " + (end - start) + " ms");
        }

        return "Finalizado con hilos virtuales";
    }

    private void simulateHeavyTask() {
        try {
            System.out.println(Thread.currentThread());
            Thread.sleep(3000); // Simula una tarea pesada de 3 segundos
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

---

📊 Resultados del Benchmark

Ejecutamos 10,000 tareas, cada una con un sleep de 3 segundos.

Método	Tiempo total ⏳	Hilos en uso 🔄
Hilos tradicionales (FixedThreadPool 10)	❌ ~30s	Máximo 10 hilos
Hilos virtuales	🚀 ~3s	10,000 hilos sin bloqueos!

📌 Conclusión: Los hilos virtuales permiten manejar miles de tareas en paralelo sin bloqueos, lo que los hace infinitamente más escalables.

---

📢 Conclusión

Los hilos virtuales de Project Loom en Java 21 son una revolución en la programación concurrente.
Si necesitas manejar miles o millones de tareas concurrentes, Project Loom es el camino a seguir. 🚀🔥

---

👨‍💻 Autor

📌 Creador: Carlos Exposito (Frody)
📌 GitHub: FirstOnDie
📌 Contacto: LinkedIn