¿Cómo funciona el multithreading en Java?

Question

Accepted Answer

**El multithreading** permite que un programa Java ejecute múltiples threads simultáneamente, habilitando paralelismo (uso de múltiples núcleos de CPU) y responsividad (ejecutar trabajo sin bloquear). Java tiene soporte de threads de primera clase — pero el estado mutable compartido introduce complejidad (race conditions) que debe manejarse cuidadosamente. ## Creación de threads ```java // 1. Implement Runnable (preferred — separates task from thread) Runnable task = () -> System.out.println("running on " + Thread.currentThread().getName()); Thread t = new Thread(task); t.start(); // start() runs it on a NEW thread (run() would run on the CURRENT thread!) // 2. modern: use an ExecutorService instead of raw threads ExecutorService executor = Executors.newFixedThreadPool(4); executor.submit(task); ``` **Punto clave a tener en cuenta:** llama `start()` (genera un nuevo thread), no `run()` (que simplemente ejecuta el código en el thread actual de forma síncrona). ## El problema central: race conditions ```java // ❌ multiple threads modifying shared state → unpredictable results class Counter { int count = 0; void increment() { count++; } // NOT atomic: read → add → write (can interleave) } // 1000 threads each incrementing 1000 times → final count is often < 1,000,000! ``` `count++` son en realidad tres operaciones (lectura, incremento, escritura). Cuando los threads se entrelazan, las actualizaciones se pierden — una **race condition**. Este es el desafío central de la concurrencia: estado mutable compartido accedido por múltiples threads sin coordinación. ## Soluciones para estado compartido seguro ```java // 1. synchronized — only one thread in the method/block at a time (a lock) synchronized void increment() { count++; } // 2. atomic classes — lock-free atomic operations AtomicInteger count = new AtomicInteger(0); count.incrementAndGet(); // atomic, thread-safe, efficient // 3. concurrent collections — built for multi-threaded access ConcurrentHashMap map = new ConcurrentHashMap<>(); // 4. immutability — immutable objects are inherently thread-safe (nothing to corrupt) ``` ## Coordinación de threads ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## El enfoque moderno: no gestiones threads crudos ```text ✓ Use ExecutorService / thread pools (not new Thread() per task — expensive) ✓ Use CompletableFuture for async composition ✓ Use concurrent collections and atomic classes over manual synchronization ✓ Java 21+ adds Virtual Threads — millions of lightweight threads for I/O concurrency ``` ## Por qué es importante El multithreading permite que los programas Java utilicen múltiples núcleos y sigan siendo responsivos, pero también es una de las áreas más difíciles de implementar correctamente — las **race conditions** del estado mutable compartido no sincronizado causan errores intermitentes y difíciles de reproducir. Comprender cómo funcionan los threads (`start()` vs `run()`), el problema central de race-condition (por qué `count++` no es seguro) y las herramientas para garantizar la seguridad (`synchronized`, clases atómicas, colecciones concurrentes, inmutabilidad) es esencial para escribir código concurrente correcto. La mejor práctica moderna favorece abstracciones de nivel superior (ExecutorService, CompletableFuture, threads virtuales) sobre la gestión de threads crudos. Este es conocimiento crítico para Java del lado del servidor y de alto rendimiento, y un tema profundo y frecuentemente evaluado que separa a desarrolladores competentes de expertos.