## Creación y ciclo de vida de threads La **concurrencia** en Java nos permite ejecutar múltiples tareas simultáneamente, aprovechando mejor los recursos del sistema. Los **threads** (hilos) son la unidad básica de ejecución concurrente en Java, permitiendo que un programa realice varias operaciones al mismo tiempo. ### Fundamentos de los threads Un thread en Java representa un **flujo de ejecución independiente** dentro de un programa. Cuando ejecutamos una aplicación Java, el JVM crea automáticamente un thread principal (main thread) que ejecuta el método `main()`. A partir de este thread principal, podemos crear threads adicionales para realizar tareas en paralelo. ### Creación de threads en Java Java ofrece dos formas principales para crear threads: * **Extendiendo la clase Thread**: Creamos una subclase de `Thread` y sobrescribimos el método `run()`. * **Implementando la interfaz Runnable**: Implementamos la interfaz `Runnable` y pasamos la instancia a un objeto `Thread`. Veamos la primera aproximación: ```java public class MiThread extends Thread { @Override public void run() { // Código que se ejecutará en el nuevo thread System.out.println("Ejecutando en thread: " + Thread.currentThread().getName()); } public static void main(String[] args) { // Creamos una instancia de nuestro thread MiThread thread = new MiThread(); // Iniciamos el thread thread.start(); // Este código se ejecuta en el thread principal System.out.println("Ejecutando en thread principal: " + Thread.currentThread().getName()); } } ``` Es importante destacar que debemos llamar al método `start()` para iniciar un nuevo thread, no al método `run()` directamente. El método `start()` realiza la inicialización necesaria y luego llama a `run()` en el nuevo thread. ### Estados del ciclo de vida de un thread Un thread en Java pasa por varios **estados** durante su ciclo de vida: 1. **NEW**: El thread ha sido creado pero aún no ha iniciado su ejecución. 2. **RUNNABLE**: El thread está ejecutándose o listo para ejecutarse cuando el planificador le asigne tiempo de CPU. 3. **BLOCKED**: El thread está bloqueado esperando un monitor lock. 4. **WAITING**: El thread está esperando indefinidamente a que otro thread realice una acción específica. 5. **TIMED_WAITING**: El thread está esperando durante un tiempo específico a que otro thread realice una acción. 6. **TERMINATED**: El thread ha completado su ejecución. Podemos consultar el estado actual de un thread mediante el método `getState()`: ```java Thread thread = new MiThread(); System.out.println("Estado inicial: " + thread.getState()); // NEW thread.start(); System.out.println("Estado después de start(): " + thread.getState()); // RUNNABLE try { thread.join(); // Espera a que el thread termine } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Estado final: " + thread.getState()); // TERMINATED ``` ### Transiciones entre estados El siguiente diagrama conceptual muestra las transiciones entre los diferentes estados de un thread: 1. Un thread comienza en estado **NEW** cuando se crea. 2. Cuando se llama a `start()`, pasa a estado **RUNNABLE**. 3. Desde **RUNNABLE** puede pasar a: - **BLOCKED**: Al intentar adquirir un monitor lock que está en uso. - **WAITING**: Al llamar a `wait()`, `join()` sin timeout. - **TIMED_WAITING**: Al llamar a `sleep()`, `wait()` con timeout, `join()` con timeout. 4. Desde **BLOCKED**, **WAITING** o **TIMED_WAITING** vuelve a **RUNNABLE** cuando se cumplen las condiciones de espera. 5. Finalmente, cuando el método `run()` termina, pasa a **TERMINATED**. ### Métodos importantes para el control de threads Java proporciona varios **métodos clave** para controlar el ciclo de vida de los threads: * **start()**: Inicia la ejecución del thread, cambiando su estado de NEW a RUNNABLE. * **sleep(long millis)**: Pausa la ejecución del thread actual durante el tiempo especificado. * **join()**: Espera a que el thread termine su ejecución. * **yield()**: Sugiere al planificador que puede ceder el tiempo de CPU a otros threads. * **interrupt()**: Interrumpe un thread que está en estado WAITING, TIMED_WAITING o BLOCKED. Veamos un ejemplo que ilustra algunos de estos métodos: ```java public class CicloVidaThread { public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(() -> { try { System.out.println("Thread iniciado"); Thread.sleep(2000); // El thread pasa a TIMED_WAITING System.out.println("Thread despertado"); } catch (InterruptedException e) { System.out.println("Thread interrumpido"); return; // Termina el thread si es interrumpido } System.out.println("Thread completando su ejecución"); }); System.out.println("Estado antes de start(): " + thread.getState()); thread.start(); System.out.println("Estado después de start(): " + thread.getState()); Thread.sleep(1000); // Damos tiempo para que el thread entre en sleep System.out.println("Estado durante sleep(): " + thread.getState()); thread.join(); // Esperamos a que el thread termine System.out.println("Estado después de terminar: " + thread.getState()); } } ``` ### Prioridades de threads Java permite asignar **prioridades** a los threads mediante el método `setPriority(int)`. Las prioridades van de 1 (mínima) a 10 (máxima), con 5 como valor predeterminado: ```java Thread thread = new Thread(() -> { // Código del thread }); thread.setPriority(Thread.MAX_PRIORITY); // Prioridad 10 thread.start(); ``` Es importante tener en cuenta que las prioridades son solo **sugerencias** para el planificador del sistema operativo, y su implementación puede variar entre diferentes plataformas. ### Threads daemon Los **threads daemon** son threads de segundo plano que no impiden que la JVM termine cuando todos los threads no-daemon han finalizado. Son útiles para tareas de mantenimiento o servicios que no necesitan completarse antes de que el programa termine: ```java Thread daemonThread = new Thread(() -> { while (true) { try { Thread.sleep(1000); System.out.println("Daemon thread trabajando..."); } catch (InterruptedException e) { break; } } }); daemonThread.setDaemon(true); // Establecer como daemon antes de iniciar daemonThread.start(); // El programa principal continúa Thread.sleep(3000); System.out.println("Programa principal terminando"); // Al terminar el thread principal, el daemon thread también terminará ``` ### Manejo de excepciones en threads Las **excepciones no capturadas** en un thread provocan la terminación del thread, pero no afectan a otros threads ni al thread principal. Para manejar estas excepciones, podemos establecer un `UncaughtExceptionHandler`: ```java Thread thread = new Thread(() -> { throw new RuntimeException("Error en el thread"); }); thread.setUncaughtExceptionHandler((t, e) -> { System.out.println("Thread " + t.getName() + " falló con excepción: " + e.getMessage()); }); thread.start(); ``` ### Ejemplo práctico: Monitoreo del ciclo de vida El siguiente ejemplo muestra cómo podemos monitorear los cambios de estado de un thread durante su ciclo de vida: ```java public class MonitoreoThread { public static void main(String[] args) throws InterruptedException { Object lock = new Object(); Thread thread = new Thread(() -> { try { // Entramos en estado RUNNABLE for (int i = 0; i < 3; i++) { System.out.println("Iteración " + i); Thread.sleep(500); // TIMED_WAITING } synchronized (lock) { // Esperamos indefinidamente - WAITING lock.wait(); } } catch (InterruptedException e) { System.out.println("Thread interrumpido"); } }); // Creamos un thread observador Thread monitor = new Thread(() -> { Thread.State estadoAnterior = thread.getState(); System.out.println("Estado inicial: " + estadoAnterior); while (thread.isAlive()) { Thread.State estadoActual = thread.getState(); if (estadoActual != estadoAnterior) { System.out.println("Transición de estado: " + estadoAnterior + " -> " + estadoActual); estadoAnterior = estadoActual; } try { Thread.sleep(100); } catch (InterruptedException e) { break; } } }); monitor.start(); thread.start(); // Damos tiempo para que el thread entre en WAITING Thread.sleep(2000); synchronized (lock) { // Notificamos al thread para que salga de WAITING lock.notify(); } // Esperamos a que ambos threads terminen thread.join(); monitor.join(); } } ``` Este ejemplo muestra cómo un thread pasa por diferentes estados durante su ejecución y cómo podemos observar estas transiciones. Entender el ciclo de vida de los threads es fundamental para desarrollar aplicaciones concurrentes robustas y eficientes en Java. ## Implementación de Runnable vs. extender Thread En Java existen dos **enfoques principales** para crear threads: extender la clase `Thread` o implementar la interfaz `Runnable`. Aunque ambos métodos permiten ejecutar código concurrentemente, presentan diferencias significativas en términos de diseño, flexibilidad y buenas prácticas. ### Enfoque 1: Extender la clase Thread Cuando extendemos la clase `Thread`, creamos una subclase especializada que hereda todos los métodos y propiedades de la clase base: ```java public class MiThread extends Thread { @Override public void run() { System.out.println("Ejecutando tarea en: " + Thread.currentThread().getName()); // Lógica de la tarea } } // Uso: MiThread miThread = new MiThread(); miThread.start(); ``` Este enfoque es **directo** y puede parecer más sencillo inicialmente, pero presenta algunas limitaciones importantes. ### Enfoque 2: Implementar la interfaz Runnable Al implementar `Runnable`, separamos la tarea a ejecutar de su mecanismo de ejecución: ```java public class MiTarea implements Runnable { @Override public void run() { System.out.println("Ejecutando tarea en: " + Thread.currentThread().getName()); // Lógica de la tarea } } // Uso: Thread thread = new Thread(new MiTarea()); thread.start(); ``` También podemos usar **expresiones lambda** para crear implementaciones de `Runnable` de forma más concisa: ```java Runnable tarea = () -> { System.out.println("Tarea ejecutándose en: " + Thread.currentThread().getName()); // Lógica de la tarea }; Thread thread = new Thread(tarea); thread.start(); ``` ### Comparación detallada Analicemos las **ventajas y desventajas** de cada enfoque: #### 1. Herencia vs. Composición * **Extender Thread**: Utiliza herencia, lo que significa que cada instancia es un thread. * **Implementar Runnable**: Utiliza composición, separando la tarea (qué hacer) del thread (cómo ejecutarla). ```java // Con herencia - cada instancia es un thread class DescargarArchivo extends Thread { private String url; public DescargarArchivo(String url) { this.url = url; } @Override public void run() { System.out.println("Descargando desde " + url); // Código de descarga } } // Con composición - la tarea es independiente del thread class TareaDescarga implements Runnable { private String url; public TareaDescarga(String url) { this.url = url; } @Override public void run() { System.out.println("Descargando desde " + url); // Código de descarga } } ``` #### 2. Flexibilidad de diseño * **Extender Thread**: Limita la herencia, ya que Java no permite herencia múltiple. Si nuestra clase ya extiende otra, no podemos extender `Thread`. * **Implementar Runnable**: Permite implementar múltiples interfaces además de `Runnable`, manteniendo la flexibilidad de diseño. ```java // Esto no es posible en Java debido a la falta de herencia múltiple class MiServicio extends ServicioBase extends Thread { ... } // Esto sí es posible class MiServicio extends ServicioBase implements Runnable, AutoCloseable { @Override public void run() { ... } @Override public void close() { ... } } ``` #### 3. Reutilización de tareas * **Extender Thread**: Cada instancia es un thread único que solo puede iniciarse una vez. * **Implementar Runnable**: La misma instancia `Runnable` puede ejecutarse en múltiples threads o reutilizarse. ```java // Con Runnable, podemos reutilizar la misma tarea en múltiples threads Runnable tarea = new MiTarea(); // Ejecutar la misma tarea en tres threads diferentes Thread thread1 = new Thread(tarea); Thread thread2 = new Thread(tarea); Thread thread3 = new Thread(tarea); thread1.start(); thread2.start(); thread3.start(); ``` #### 4. Uso de pools de threads * **Extender Thread**: No se integra bien con los pools de threads del paquete `java.util.concurrent`. * **Implementar Runnable**: Se integra perfectamente con `ExecutorService` y otros componentes de concurrencia avanzados. ```java // Usando ExecutorService con Runnable ExecutorService executor = Executors.newFixedThreadPool(3); // Podemos enviar tareas Runnable directamente executor.submit(new MiTarea()); executor.submit(() -> System.out.println("Tarea con lambda")); // Cerramos el executor cuando terminamos executor.shutdown(); ``` #### 5. Compartir estado entre threads * **Extender Thread**: Dificulta compartir estado entre múltiples threads. * **Implementar Runnable**: Facilita compartir datos entre threads que ejecutan la misma tarea. ```java // Compartiendo estado con Runnable class ContadorCompartido implements Runnable { private int contador = 0; @Override public void run() { synchronized(this) { contador++; System.out.println(Thread.currentThread().getName() + " incrementó contador a: " + contador); } } } // La misma instancia compartida entre threads ContadorCompartido contador = new ContadorCompartido(); new Thread(contador, "Thread-1").start(); new Thread(contador, "Thread-2").start(); new Thread(contador, "Thread-3").start(); ``` ### Ejemplo práctico: Simulación de descarga Veamos un ejemplo más completo que ilustra las diferencias entre ambos enfoques. Implementaremos una simulación de descarga de archivos: #### Usando Thread: ```java public class DescargadorThread extends Thread { private final String archivo; private final int tiempoEstimado; public DescargadorThread(String archivo, int tiempoEstimado) { this.archivo = archivo; this.tiempoEstimado = tiempoEstimado; } @Override public void run() { System.out.println("Iniciando descarga de " + archivo); try { // Simulamos el tiempo de descarga Thread.sleep(tiempoEstimado); System.out.println("Descarga completa: " + archivo); } catch (InterruptedException e) { System.out.println("Descarga interrumpida: " + archivo); Thread.currentThread().interrupt(); } } public static void main(String[] args) { DescargadorThread d1 = new DescargadorThread("video.mp4", 3000); DescargadorThread d2 = new DescargadorThread("imagen.jpg", 1000); DescargadorThread d3 = new DescargadorThread("documento.pdf", 2000); d1.start(); d2.start(); d3.start(); } } ``` #### Usando Runnable: ```java public class TareaDescarga implements Runnable { private final String archivo; private final int tiempoEstimado; public TareaDescarga(String archivo, int tiempoEstimado) { this.archivo = archivo; this.tiempoEstimado = tiempoEstimado; } @Override public void run() { System.out.println("Iniciando descarga de " + archivo); try { // Simulamos el tiempo de descarga Thread.sleep(tiempoEstimado); System.out.println("Descarga completa: " + archivo); } catch (InterruptedException e) { System.out.println("Descarga interrumpida: " + archivo); Thread.currentThread().interrupt(); } } public static void main(String[] args) { // Usando threads individuales Thread t1 = new Thread(new TareaDescarga("video.mp4", 3000)); Thread t2 = new Thread(new TareaDescarga("imagen.jpg", 1000)); Thread t3 = new Thread(new TareaDescarga("documento.pdf", 2000)); t1.start(); t2.start(); t3.start(); // Alternativa: usando un pool de threads ExecutorService executor = Executors.newFixedThreadPool(3); executor.submit(new TareaDescarga("archivo1.zip", 2500)); executor.submit(new TareaDescarga("archivo2.zip", 1500)); executor.submit(new TareaDescarga("archivo3.zip", 3500)); // Cerramos el executor cuando terminamos executor.shutdown(); } } ``` ### Implementación con expresiones lambda y métodos referenciados Con Java 8 y posteriores, podemos aprovechar las **expresiones lambda** y **referencias a métodos** para crear implementaciones de `Runnable` más concisas: ```java public class EjemplosModernos { public static void descargarArchivo(String nombre) { System.out.println("Descargando " + nombre + " en " + Thread.currentThread().getName()); try { Thread.sleep(1000); System.out.println("Descarga completa: " + nombre); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } public static void main(String[] args) { // Usando lambda Thread t1 = new Thread(() -> { System.out.println("Ejecutando en " + Thread.currentThread().getName()); // Lógica de la tarea }); // Usando referencia a método Thread t2 = new Thread(() -> descargarArchivo("config.xml")); // Con ExecutorService y lambdas ExecutorService executor = Executors.newCachedThreadPool(); // Enviando múltiples tareas for (int i = 1; i <= 5; i++) { final String nombreArchivo = "archivo" + i + ".dat"; executor.submit(() -> descargarArchivo(nombreArchivo)); } t1.start(); t2.start(); executor.shutdown(); } } ``` ### Recomendaciones y mejores prácticas Basándonos en las comparaciones anteriores, podemos establecer algunas **recomendaciones**: * **Preferir Runnable sobre Thread**: La implementación de `Runnable` ofrece mayor flexibilidad, mejor diseño orientado a objetos y se alinea con el principio de separación de responsabilidades. * **Usar expresiones lambda** para tareas simples: Cuando la lógica de la tarea es breve, las expresiones lambda proporcionan una sintaxis concisa. * **Considerar ExecutorService** para gestionar threads: En lugar de crear threads manualmente, utilizar los servicios de ejecución del paquete `java.util.concurrent`. * **Evitar extender Thread** a menos que realmente necesites personalizar el comportamiento del thread en sí (no solo la tarea que ejecuta). * **Implementar Callable** en lugar de `Runnable` cuando necesites devolver un resultado o lanzar excepciones comprobadas. ```java // Ejemplo con Callable (devuelve un resultado) Callable tarea = () -> { Thread.sleep(1000); return 42; // Devuelve un resultado }; ExecutorService executor = Executors.newSingleThreadExecutor(); Future resultado = executor.submit(tarea); try { System.out.println("Resultado: " + resultado.get()); } catch (Exception e) { e.printStackTrace(); } executor.shutdown(); ``` La elección entre extender `Thread` e implementar `Runnable` puede parecer trivial, pero tiene implicaciones importantes en el diseño y mantenimiento de aplicaciones concurrentes. En la mayoría de los casos, implementar `Runnable` proporciona un diseño más flexible y modular, alineado con los principios modernos de programación en Java. ## Sincronización básica y palabra clave synchronized Cuando trabajamos con múltiples threads en Java, surge un **problema fundamental**: el acceso concurrente a recursos compartidos puede provocar resultados impredecibles o incorrectos. La **sincronización** es el mecanismo que nos permite coordinar la ejecución de threads para garantizar la integridad de los datos compartidos. ### El problema de la concurrencia Imaginemos una situación donde dos threads intentan incrementar un contador compartido: ```java public class ContadorInseguro { private int contador = 0; public void incrementar() { contador++; // Esta operación no es atómica } public int getValor() { return contador; } public static void main(String[] args) throws InterruptedException { ContadorInseguro contador = new ContadorInseguro(); Thread t1 = new Thread(() -> { for (int i = 0; i < 10000; i++) { contador.incrementar(); } }); Thread t2 = new Thread(() -> { for (int i = 0; i < 10000; i++) { contador.incrementar(); } }); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println("Valor final: " + contador.getValor()); } } ``` Al ejecutar este código, esperaríamos que el valor final fuera 20000, pero frecuentemente obtendremos un valor menor. Esto ocurre porque la operación `contador++` no es **atómica** - en realidad consta de tres pasos: 1. Leer el valor actual 2. Incrementarlo 3. Escribir el nuevo valor Si dos threads ejecutan estos pasos simultáneamente, pueden producirse **condiciones de carrera** donde un thread sobrescribe los cambios del otro. ### La palabra clave synchronized Java proporciona la palabra clave `synchronized` para crear **secciones críticas** - bloques de código que solo pueden ser ejecutados por un thread a la vez: ```java public class ContadorSeguro { private int contador = 0; public synchronized void incrementar() { contador++; } public synchronized int getValor() { return contador; } } ``` Cuando un método se declara como `synchronized`, Java utiliza el objeto actual (`this`) como **monitor** o **lock**. Antes de que un thread pueda ejecutar el método, debe adquirir el lock del objeto. Si otro thread ya tiene el lock, el thread solicitante se bloquea hasta que el lock esté disponible. ### Bloques synchronized También podemos sincronizar solo partes específicas de un método usando **bloques synchronized**: ```java public class ContadorOptimizado { private int contador = 0; public void incrementar() { // Código no sincronizado synchronized(this) { contador++; } // Más código no sincronizado } public int getValor() { synchronized(this) { return contador; } } } ``` Esta aproximación es más **eficiente** cuando solo una pequeña parte del método necesita sincronización, ya que minimiza el tiempo que los threads pasan bloqueados. ### Sincronización en objetos específicos Podemos sincronizar sobre cualquier objeto, no solo `this`: ```java public class BancoSincronizado { private final Object lockCuentas = new Object(); // objeto para sincronización private int[] cuentas = new int[100]; public void transferir(int origen, int destino, int cantidad) { synchronized(lockCuentas) { if (cuentas[origen] >= cantidad) { cuentas[origen] -= cantidad; cuentas[destino] += cantidad; } } } public int saldoTotal() { synchronized(lockCuentas) { int suma = 0; for (int saldo : cuentas) { suma += saldo; } return suma; } } } ``` Usar un objeto dedicado para la sincronización (como `lockCuentas`) es una **buena práctica** porque: 1. Hace explícito qué recurso está siendo protegido 2. Evita interferencias con otros mecanismos de sincronización 3. Proporciona un control más granular sobre la sincronización ### Métodos estáticos synchronized Para sincronizar métodos estáticos, Java utiliza el **lock de la clase** en lugar del lock de la instancia: ```java public class Contador { private static int contador = 0; public static synchronized void incrementar() { contador++; } public static synchronized int getValor() { return contador; } } ``` Esto es equivalente a: ```java public class Contador { private static int contador = 0; public static void incrementar() { synchronized(Contador.class) { contador++; } } public static int getValor() { synchronized(Contador.class) { return contador; } } } ``` ### Sincronización de colecciones Las colecciones estándar de Java como `ArrayList` o `HashMap` no son thread-safe. Para operaciones concurrentes, podemos: 1. Usar colecciones sincronizadas: ```java List listaSincronizada = Collections.synchronizedList(new ArrayList<>()); Map mapaSincronizado = Collections.synchronizedMap(new HashMap<>()); // Uso seguro en múltiples threads listaSincronizada.add("elemento"); mapaSincronizado.put("clave", 42); ``` 2. Usar colecciones concurrentes del paquete `java.util.concurrent`: ```java ConcurrentHashMap mapaSeguro = new ConcurrentHashMap<>(); CopyOnWriteArrayList listaSegura = new CopyOnWriteArrayList<>(); // Estas colecciones están optimizadas para concurrencia mapaSeguro.put("clave", 100); listaSegura.add("elemento"); ``` ### Sincronización y visibilidad La sincronización no solo previene el acceso simultáneo, también garantiza la **visibilidad** de los cambios entre threads. Cuando un thread sale de un bloque sincronizado, todos los cambios realizados dentro del bloque se vuelven visibles para otros threads que adquieran el mismo lock. ```java public class EjemploVisibilidad { private boolean listo = false; private int dato = 0; public synchronized void producir() { dato = 42; listo = true; } public synchronized void consumir() { if (listo) { System.out.println("Dato: " + dato); // Siempre verá 42 } } } ``` Sin sincronización, el thread consumidor podría ver `listo = true` pero no ver el valor actualizado de `dato` debido a la **reordenación de instrucciones** y el **caching** en los procesadores modernos. ### Sincronización y rendimiento Aunque la sincronización es necesaria para la corrección, tiene un **impacto en el rendimiento**: 1. **Overhead de adquisición de locks**: Adquirir y liberar locks tiene un costo. 2. **Contención**: Los threads que esperan un lock no pueden avanzar. 3. **Reducción del paralelismo**: La sincronización limita la ejecución concurrente. Por ello, es importante seguir algunas **buenas prácticas**: * **Minimizar el alcance** de los bloques sincronizados * **Sincronizar solo lo necesario** * **Usar locks de grano fino** para recursos independientes * **Considerar alternativas** como variables atómicas o estructuras sin bloqueo ### Variables atómicas como alternativa Para operaciones simples, las clases del paquete `java.util.concurrent.atomic` ofrecen una alternativa más eficiente: ```java import java.util.concurrent.atomic.AtomicInteger; public class ContadorAtomico { private AtomicInteger contador = new AtomicInteger(0); public void incrementar() { contador.incrementAndGet(); // Operación atómica } public int getValor() { return contador.get(); } } ``` Las variables atómicas utilizan instrucciones especiales del procesador (como Compare-And-Swap) para realizar operaciones sin bloqueos, lo que las hace más **eficientes** en situaciones de baja contención. ### Ejemplo práctico: Banco con transferencias seguras Veamos un ejemplo más completo de sincronización en una aplicación bancaria: ```java public class Banco { private final double[] cuentas; private final Object lockCuentas = new Object(); public Banco(int numCuentas, double saldoInicial) { cuentas = new double[numCuentas]; Arrays.fill(cuentas, saldoInicial); } public void transferir(int origen, int destino, double cantidad) { synchronized(lockCuentas) { if (origen < 0 || origen >= cuentas.length || destino < 0 || destino >= cuentas.length) { throw new IllegalArgumentException("Cuenta inválida"); } if (cuentas[origen] < cantidad) { System.out.println("Fondos insuficientes"); return; } System.out.printf("Transfiriendo %.2f de cuenta %d a cuenta %d%n", cantidad, origen, destino); cuentas[origen] -= cantidad; cuentas[destino] += cantidad; System.out.printf("Saldo total: %.2f%n", getSaldoTotal()); } } public double getSaldoTotal() { synchronized(lockCuentas) { return Arrays.stream(cuentas).sum(); } } public static void main(String[] args) { final int NUM_CUENTAS = 10; final double SALDO_INICIAL = 1000; final int NUM_THREADS = 5; final int NUM_TRANSFERENCIAS = 50; Banco banco = new Banco(NUM_CUENTAS, SALDO_INICIAL); for (int i = 0; i < NUM_THREADS; i++) { Thread t = new Thread(() -> { Random random = new Random(); for (int j = 0; j < NUM_TRANSFERENCIAS; j++) { int origen = random.nextInt(NUM_CUENTAS); int destino; do { destino = random.nextInt(NUM_CUENTAS); } while (destino == origen); double cantidad = random.nextDouble() * 100; banco.transferir(origen, destino, cantidad); try { Thread.sleep(random.nextInt(10)); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } }); t.start(); } } } ``` En este ejemplo, utilizamos sincronización para garantizar que: 1. Las transferencias son **atómicas** - no pueden ser interrumpidas a la mitad 2. El saldo total se mantiene **constante** (conservación del dinero) 3. Las verificaciones de saldo y las transferencias son **consistentes** ### Sincronización con múltiples locks En aplicaciones complejas, a veces necesitamos múltiples locks. Es importante tener cuidado con el **orden de adquisición** para evitar deadlocks: ```java public class TransferenciaSegura { private final Object lock1 = new Object(); private final Object lock2 = new Object(); private double saldo1 = 1000; private double saldo2 = 1000; public void transferir1a2(double cantidad) { synchronized(lock1) { synchronized(lock2) { if (saldo1 >= cantidad) { saldo1 -= cantidad; saldo2 += cantidad; } } } } public void transferir2a1(double cantidad) { // Importante: mismo orden de adquisición que en transferir1a2 synchronized(lock1) { synchronized(lock2) { if (saldo2 >= cantidad) { saldo2 -= cantidad; saldo1 += cantidad; } } } } } ``` Si usáramos un orden diferente de locks en `transferir2a1` (primero `lock2` y luego `lock1`), podríamos crear condiciones para un **deadlock**. La sincronización es un concepto fundamental en la programación concurrente en Java. Aunque la palabra clave `synchronized` proporciona una forma sencilla de proteger recursos compartidos, es importante entender sus implicaciones y utilizarla correctamente para evitar problemas de rendimiento y concurrencia. ## Problemas comunes: deadlock, race conditions La programación concurrente en Java ofrece grandes ventajas para aprovechar los recursos del sistema, pero también introduce **desafíos específicos** que pueden ser difíciles de detectar y resolver. Dos de los problemas más comunes y peligrosos son los deadlocks y las race conditions. ### Race conditions (condiciones de carrera) Una **race condition** ocurre cuando el comportamiento de un programa depende del orden relativo o la sincronización de eventos que no están bajo el control del programador. Típicamente, esto sucede cuando múltiples threads acceden y modifican datos compartidos sin la sincronización adecuada. Veamos un ejemplo clásico de una condición de carrera: ```java public class ContadorInseguro implements Runnable { private static int contador = 0; @Override public void run() { for (int i = 0; i < 1000; i++) { // Operación no atómica vulnerable a race conditions contador = contador + 1; } } public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(new ContadorInseguro()); Thread t2 = new Thread(new ContadorInseguro()); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println("Valor final del contador: " + contador); // El resultado esperado sería 2000, pero casi siempre será menor } } ``` #### ¿Por qué ocurre? La operación `contador = contador + 1` parece simple, pero en realidad involucra tres pasos: 1. Leer el valor actual de `contador` 2. Incrementar el valor en 1 3. Escribir el nuevo valor en `contador` Si dos threads ejecutan estos pasos simultáneamente, pueden **interferir entre sí**: ``` Thread 1: Lee contador (valor 42) Thread 2: Lee contador (valor 42) Thread 1: Incrementa a 43 Thread 2: Incrementa a 43 Thread 1: Escribe 43 en contador Thread 2: Escribe 43 en contador ``` En este escenario, aunque ambos threads incrementaron el contador, el valor final es 43 en lugar de 44, perdiendo un incremento. #### Detección de race conditions Las race conditions son **notoriamente difíciles** de detectar porque: * Pueden no manifestarse en cada ejecución * A menudo dependen de la carga del sistema y la planificación de threads * Pueden aparecer solo en producción bajo carga real Algunas herramientas que ayudan a detectarlas: * **Analizadores estáticos**: FindBugs, SpotBugs, SonarQube * **Herramientas de análisis dinámico**: Java PathFinder, ThreadSanitizer * **Pruebas de estrés**: Ejecutar el código con muchos threads simultáneos #### Soluciones para race conditions 1. **Sincronización con synchronized**: ```java public class ContadorSeguro implements Runnable { private static int contador = 0; private static final Object lock = new Object(); @Override public void run() { for (int i = 0; i < 1000; i++) { synchronized(lock) { contador = contador + 1; } } } } ``` 2. **Uso de variables atómicas**: ```java import java.util.concurrent.atomic.AtomicInteger; public class ContadorAtomico implements Runnable { private static AtomicInteger contador = new AtomicInteger(0); @Override public void run() { for (int i = 0; i < 1000; i++) { contador.incrementAndGet(); // Operación atómica } } } ``` 3. **Uso de estructuras thread-safe**: ```java import java.util.concurrent.ConcurrentHashMap; // En lugar de HashMap normal ConcurrentHashMap mapaSeguro = new ConcurrentHashMap<>(); ``` ### Deadlocks Un **deadlock** ocurre cuando dos o más threads se bloquean permanentemente, esperando recursos que están siendo retenidos por otros threads en el mismo grupo. Es como si dos personas en un pasillo estrecho se detuvieran cada una esperando que la otra se mueva primero. #### Ejemplo clásico de deadlock ```java public class EjemploDeadlock { private static final Object recurso1 = new Object(); private static final Object recurso2 = new Object(); public static void main(String[] args) { Thread thread1 = new Thread(() -> { synchronized(recurso1) { System.out.println("Thread 1: Tiene recurso 1"); try { Thread.sleep(100); // Aumenta la probabilidad de deadlock } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Thread 1: Esperando recurso 2"); synchronized(recurso2) { System.out.println("Thread 1: Tiene ambos recursos"); } } }); Thread thread2 = new Thread(() -> { synchronized(recurso2) { System.out.println("Thread 2: Tiene recurso 2"); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Thread 2: Esperando recurso 1"); synchronized(recurso1) { System.out.println("Thread 2: Tiene ambos recursos"); } } }); thread1.start(); thread2.start(); } } ``` En este ejemplo: 1. El **Thread 1** adquiere `recurso1` y luego intenta adquirir `recurso2` 2. El **Thread 2** adquiere `recurso2` y luego intenta adquirir `recurso1` 3. Ambos threads quedan bloqueados indefinidamente, esperando un recurso que nunca será liberado #### Las cuatro condiciones para un deadlock Un deadlock puede ocurrir solo cuando se cumplen estas cuatro condiciones simultáneamente: 1. **Exclusión mutua**: Al menos un recurso debe ser retenido en modo no compartible 2. **Retención y espera**: Un thread retiene al menos un recurso mientras espera recursos adicionales 3. **No apropiación**: Los recursos no pueden ser forzosamente quitados de los threads 4. **Espera circular**: Existe un ciclo de threads donde cada uno espera un recurso retenido por el siguiente #### Detección de deadlocks Java proporciona herramientas para detectar deadlocks: 1. **jstack**: Herramienta de línea de comandos que muestra volcados de threads de JVM: ```bash jstack ``` 2. **JVisualVM o JConsole**: Herramientas gráficas que pueden detectar deadlocks 3. **ThreadMXBean**: API para detectar deadlocks programáticamente: ```java import java.lang.management.ManagementFactory; import java.lang.management.ThreadMXBean; public class DetectorDeadlock { public static void detectarDeadlock() { ThreadMXBean threadBean = ManagementFactory.getThreadMXBean(); long[] threadIds = threadBean.findDeadlockedThreads(); if (threadIds != null) { System.out.println("¡Deadlock detectado!"); // Obtener información detallada de los threads for (long id : threadIds) { System.out.println(threadBean.getThreadInfo(id, Integer.MAX_VALUE)); } } else { System.out.println("No se detectaron deadlocks"); } } } ``` #### Prevención de deadlocks 1. **Ordenamiento de locks**: Siempre adquirir múltiples locks en el mismo orden: ```java public void transferir(Cuenta origen, Cuenta destino, double cantidad) { // Ordenamos las cuentas para adquirir locks siempre en el mismo orden Cuenta primera = origen.getId() < destino.getId() ? origen : destino; Cuenta segunda = origen.getId() < destino.getId() ? destino : origen; synchronized(primera) { synchronized(segunda) { // Realizar la transferencia if (origen == primera) { origen.retirar(cantidad); destino.depositar(cantidad); } else { destino.retirar(cantidad); origen.depositar(cantidad); } } } } ``` 2. **Uso de timeouts**: Evitar esperas indefinidas con `tryLock()` de `ReentrantLock`: ```java import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class TransferenciaConTimeout { private final Lock lock = new ReentrantLock(); public boolean transferir(Cuenta origen, Cuenta destino, double cantidad) { try { if (origen.lock.tryLock(1, TimeUnit.SECONDS)) { try { if (destino.lock.tryLock(1, TimeUnit.SECONDS)) { try { if (origen.getSaldo() >= cantidad) { origen.retirar(cantidad); destino.depositar(cantidad); return true; } } finally { destino.lock.unlock(); } } } finally { origen.lock.unlock(); } } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } return false; // No se pudo adquirir ambos locks } } ``` 3. **Evitar anidamiento de locks**: Minimizar la cantidad de locks adquiridos simultáneamente 4. **Usar estructuras de alto nivel**: Utilizar clases del paquete `java.util.concurrent` que manejan la sincronización internamente ### Livelock Un **livelock** es similar a un deadlock, pero los threads no están bloqueados - están ocupados respondiendo a las acciones de los otros threads sin hacer progreso real. Es como cuando dos personas se encuentran en un pasillo y ambas se mueven al mismo lado intentando dejar pasar a la otra. ```java public class EjemploLivelock { static class Recurso { private String nombre; private boolean enUso = false; public Recurso(String nombre) { this.nombre = nombre; } public String getNombre() { return nombre; } public boolean isEnUso() { return enUso; } public synchronized boolean usar(Trabajador trabajador) { if (enUso) { System.out.println(trabajador.getNombre() + " esperando que " + nombre + " sea liberado"); return false; } enUso = true; System.out.println(trabajador.getNombre() + " usando " + nombre); return true; } public synchronized void liberar() { enUso = false; System.out.println(nombre + " liberado"); } } static class Trabajador { private String nombre; private boolean activo = true; public Trabajador(String nombre) { this.nombre = nombre; } public String getNombre() { return nombre; } public void trabajar(Recurso recursoPropio, Recurso recursoAjeno) { while (activo) { // Si no puede usar su propio recurso, lo libera para que otro lo use if (recursoPropio.usar(this)) { System.out.println(nombre + " intentando usar " + recursoAjeno.getNombre()); if (!recursoAjeno.usar(this)) { System.out.println(nombre + " no puede usar " + recursoAjeno.getNombre() + ", liberando recursos"); recursoPropio.liberar(); // Espera para reintentar try { Thread.sleep(10); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } continue; } // Si llega aquí, tiene ambos recursos activo = false; System.out.println(nombre + " completó su trabajo"); recursoAjeno.liberar(); recursoPropio.liberar(); } } } } public static void main(String[] args) { final Recurso recursoA = new Recurso("Recurso A"); final Recurso recursoB = new Recurso("Recurso B"); final Trabajador trabajador1 = new Trabajador("Trabajador 1"); final Trabajador trabajador2 = new Trabajador("Trabajador 2"); new Thread(() -> { trabajador1.trabajar(recursoA, recursoB); }).start(); new Thread(() -> { trabajador2.trabajar(recursoB, recursoA); }).start(); } } ``` En este ejemplo, ambos trabajadores intentan ser "corteses" liberando su recurso si no pueden obtener el segundo, pero esto puede llevar a un ciclo infinito donde ninguno hace progreso. ### Starvation (inanición) La **starvation** ocurre cuando un thread no puede acceder a los recursos que necesita durante un tiempo prolongado debido a que otros threads de mayor prioridad los acaparan constantemente. ```java public class EjemploStarvation { private static Object recurso = new Object(); public static void main(String[] args) { // Creamos 5 threads con prioridad normal for (int i = 0; i < 5; i++) { Thread t = new Thread(new TrabajadorNormal()); t.setName("Thread Normal " + i); t.start(); } // Creamos un thread con alta prioridad que monopoliza el recurso Thread threadPrioritario = new Thread(new TrabajadorPrioritario()); threadPrioritario.setPriority(Thread.MAX_PRIORITY); threadPrioritario.setName("Thread Prioritario"); threadPrioritario.start(); } static class TrabajadorNormal implements Runnable { @Override public void run() { while (true) { synchronized(recurso) { System.out.println(Thread.currentThread().getName() + " obtuvo el recurso"); try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } // Tiempo fuera del bloque sincronizado try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } } } static class TrabajadorPrioritario implements Runnable { @Override public void run() { while (true) { synchronized(recurso) { System.out.println(Thread.currentThread().getName() + " obtuvo el recurso"); try { // Retiene el recurso por más tiempo Thread.sleep(200); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } // Apenas suelta el recurso, intenta obtenerlo de nuevo try { Thread.sleep(10); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } } } } ``` #### Soluciones para starvation 1. **Usar políticas de equidad**: Algunos locks en Java pueden configurarse para ser "justos": ```java import java.util.concurrent.locks.ReentrantLock; // El parámetro true activa la política de equidad ReentrantLock lockJusto = new ReentrantLock(true); ``` 2. **Reducir el tiempo de retención de recursos**: Minimizar el tiempo que un thread mantiene un lock 3. **Evitar prioridades extremas**: No abusar de las prioridades de threads ### Mejores prácticas para evitar problemas de concurrencia 1. **Inmutabilidad**: Los objetos inmutables son inherentemente thread-safe: ```java public final class Punto { private final int x; private final int y; public Punto(int x, int y) { this.x = x; this.y = y; } public int getX() { return x; } public int getY() { return y; } // No hay setters - los valores no pueden cambiar public Punto sumar(Punto otro) { // Retorna un nuevo objeto en lugar de modificar el existente return new Punto(this.x + otro.x, this.y + otro.y); } } ``` 2. **Confinamiento de threads**: Limitar el acceso a datos a un solo thread: ```java public class ConfinamientoThread { // ThreadLocal confina los datos a cada thread individual private static ThreadLocal formatoFecha = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd")); public String formatearFecha(Date fecha) { // Cada thread tiene su propia instancia de SimpleDateFormat return formatoFecha.get().format(fecha); } } ``` 3. **Minimizar el estado compartido**: Reducir la cantidad de datos que necesitan sincronización 4. **Preferir estructuras concurrentes**: Usar las clases del paquete `java.util.concurrent` 5. **Documentar la estrategia de sincronización**: Hacer explícito cómo se protegen los datos compartidos ```java /** * Esta clase es thread-safe. * La sincronización se realiza a nivel de método para proteger el estado interno. */ public class ContadorSeguro { private int valor; public synchronized void incrementar() { valor++; } public synchronized int getValor() { return valor; } } ``` 6. **Usar herramientas de análisis**: Incorporar análisis estático y dinámico en el proceso de desarrollo ### Ejemplo integrado: Sistema de reservas Veamos un ejemplo más completo que ilustra cómo evitar race conditions y deadlocks en un sistema de reservas: ```java import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class SistemaReservas { private final Map recursos = new HashMap<>(); // Constructor que inicializa recursos public SistemaReservas(int numRecursos) { for (int i = 1; i <= numRecursos; i++) { recursos.put(i, new Recurso(i, "Recurso " + i)); } } // Método seguro para reservar múltiples recursos public boolean reservar(int idUsuario, int[] idsRecursos) { // Ordenamos los IDs para evitar deadlocks java.util.Arrays.sort(idsRecursos); // Lista de recursos bloqueados para liberarlos en caso de fallo Map bloqueados = new HashMap<>(); try { // Intentamos adquirir todos los locks en orden for (int id : idsRecursos) { Recurso recurso = recursos.get(id); if (recurso == null) { throw new IllegalArgumentException("Recurso no encontrado: " + id); } if (!recurso.lock.tryLock(500, java.util.concurrent.TimeUnit.MILLISECONDS)) { // No pudimos obtener el lock, abortamos return false; } bloqueados.put(id, recurso); } // Verificamos disponibilidad de todos los recursos for (int id : idsRecursos) { Recurso recurso = recursos.get(id); if (recurso.estaReservado()) { return false; } } // Realizamos las reservas for (int id : idsRecursos) { Recurso recurso = recursos.get(id); recurso.reservar(idUsuario); System.out.println("Recurso " + id + " reservado por usuario " + idUsuario); } return true; } catch (InterruptedException e) { Thread.currentThread().interrupt(); return false; } finally { // Liberamos todos los locks adquiridos for (Recurso recurso : bloqueados.values()) { recurso.lock.unlock(); } } } // Clase interna que representa un recurso reservable static class Recurso { private final int id; private final String nombre; private int reservadoPor = -1; // -1 significa no reservado final Lock lock = new ReentrantLock(); public Recurso(int id, String nombre) { this.id = id; this.nombre = nombre; } public boolean estaReservado() { return reservadoPor != -1; } public void reservar(int idUsuario) { this.reservadoPor = idUsuario; } public void liberar() { this.reservadoPor = -1; } } // Método principal para demostración public static void main(String[] args) { final SistemaReservas sistema = new SistemaReservas(5); // Simulamos múltiples usuarios intentando reservar recursos for (int usuario = 1; usuario <= 3; usuario++) { final int idUsuario = usuario; new Thread(() -> { // Cada usuario intenta reservar 2-3 recursos aleatorios int[] recursosDeseados = generarRecursosAleatorios(2 + idUsuario % 2); System.out.println("Usuario " + idUsuario + " intenta reservar: " + java.util.Arrays.toString(recursosDeseados)); boolean exito = sistema.reservar(idUsuario, recursosDeseados); System.out.println("Usuario " + idUsuario + (exito ? " reservó con éxito" : " no pudo reservar")); }).start(); } } // Método auxiliar para generar IDs de recursos aleatorios private static int[] generarRecursosAleatorios(int cantidad) { java.util.Random random = new java.util.Random(); int[] resultado = new int[cantidad]; for (int i = 0; i < cantidad; i++) { resultado[i] = 1 + random.nextInt(5); // IDs del 1 al 5 } return resultado; } } ``` Este ejemplo implementa varias técnicas para evitar problemas de concurrencia: 1. **Ordenamiento de locks** para prevenir deadlocks 2. **Timeouts** para evitar esperas indefinidas 3. **Adquisición atómica** de todos los recursos o ninguno 4. **Liberación adecuada** de locks en bloques finally Los problemas de concurrencia como deadlocks y race conditions son desafíos inherentes a la programación multithreading. Aunque no existe una solución universal, comprender estos problemas y aplicar las técnicas adecuadas nos permite desarrollar aplicaciones concurrentes más robustas y confiables.

Objetivos de aprendizaje de esta lección