Lecciones

Patrón de comportamiento «Observador»: roles Subject y Observer, suscripción/cancelación mediante addObserver/ removeObserver, y envío de notificaciones con el método notifyObservers. Analizamos la relación con el modelo de eventos de Java: button. addActionListener( listener) ; → llamada a actionPerformed(). Práctica con ejemplos (termómetro y aire acondicionado, minicontador y lambdas), así como por qué java.util.Observable/ Observer están obsoletos y cuáles son los enfoques modernos.

En esta lección explicamos qué es el hilo de despacho de eventos de la UI — EDT en Swing y su análogo JavaFX Application Thread—, por qué los componentes de la interfaz no son seguros para hilos y por qué la ventana se «cuelga» con tareas pesadas. Mostraremos prácticas correctas: descargar los cálculos al fondo mediante new Thread(...), actualizar la interfaz con llamadas a SwingUtilities.invokeLater y Platform.runLater, así como usar herramientas de alto nivel SwingWorker<T, V> y Task<V>/ Service<V> para progreso, cancelación y manejo de errores.

Por qué las aplicaciones necesitan hilos y paralelismo: desde una interfaz receptiva hasta aprovechar todos los núcleos de la CPU. Analizamos la diferencia entre procesos e hilos, el papel del hilo principal main en la JVM, casos prácticos (UI, servidores, procesamiento de archivos) y riesgos: race condition, deadlock, así como herramientas básicas de sincronización como synchronized. Mostraremos un ejemplo sencillo con Thread y la ejecución de dos tareas en paralelo.

En la lección analizamos el lanzamiento de hilos en Java: conocemos la clase Thread y la interfaz Runnable, aprendemos a invocar correctamente start() y no confundirlo con run(), usamos clases anónimas y expresiones lambda, lanzamos varios hilos y observamos el ciclo de vida ( NEW → RUNNABLE → TERMINATED). Hablaremos de los métodos Thread.currentThread(), getName(), de la espera mediante join() y de errores típicos como IllegalThreadStateException.

Analizamos el ciclo de vida de un hilo en Java: desde Thread.State (

NEW

,

RUNNABLE

,

BLOCKED

,

WAITING

,

TIMED_WAITING

,

TERMINATED

) hasta las transiciones entre ellos. Aprendemos a gestionar hilos con Thread.sleep(...), join(), interrupt(), a diagnosticar el estado mediante isAlive() y getState(), así como a evitar métodos obsoletos como stop()/ suspend()/ resume(). Al final — consejos prácticos y errores frecuentes.

Cómo pasar parámetros de forma segura a los hilos a través del constructor de la clase que implementa Runnable, cuándo son apropiadas las expresiones lambda y por qué es mejor hacer los campos final. Analizamos las prioridades de los hilos: métodos setPriority/ getPriority, constantes Thread.MIN_PRIORITY, Thread.NORM_PRIORITY, Thread.MAX_PRIORITY y su influencia en el planificador. Además — nombrar hilos mediante el constructor, setName/ getName, ejemplo práctico y errores típicos (Runnable compartido, setters, esperanzas en las prioridades).

En la lección analizamos qué es una condición de carrera: cuando varios hilos acceden simultáneamente a datos compartidos y el resultado depende del orden de planificación. Con el ejemplo del incremento counter ++ mostramos por qué la operación no es atómica y cómo se pierden incrementos. Abordamos un caso práctico con una cuenta bancaria, las consecuencias en producción y los enfoques de protección: synchronized, tipos atómicos de java.util.concurrent.atomic (por ejemplo, AtomicInteger) y también la inmutabilidad. Cerramos con la sección «Errores típicos», donde se explica por qué los bugs de Thread rara vez los detectan las pruebas y por qué «curarlos» con Thread. sleep( 1) no tiene sentido.

Esta lección trata de qué es un recurso compartido en aplicaciones multihilo, por qué surgen condiciones de carrera (race condition) y «actualizaciones perdidas», y cómo proteger los datos con synchronized. Veremos técnicas básicas de sincronización (métodos y bloques), hablaremos de herramientas modernas de java.util.concurrent ( Lock, ReentrantLock, Semaphore y otros), veremos ejemplos prácticos con el incremento de un contador y errores típicos (no atomicidad de i ++, objeto de bloqueo incorrecto, mitos sobre volatile).

Lección práctica sobre concurrencia: analizamos cómo funciona la palabra clave synchronized (bloques y métodos, el monitor del objeto y el bloqueo a nivel de clase ClassName.class), en qué se diferencia la visibilidad de los cambios mediante volatile de la atomicidad de las operaciones, por qué las banderas boolean conviene declararlas volatile, y por qué el incremento count ++ requiere sincronización. Veremos cuándo elegir synchronized y cuándo — volatile, y analizaremos errores típicos.

Comparación práctica de la sincronización clásica mediante synchronized con primitivas más flexibles del paquete java.util.concurrent.locks: ReentrantLock y ReadWriteLock. Veremos cómo gestionar los bloqueos de forma explícita ( lock()/ unlock(), tryLock() con tiempo de espera), cómo escalar la lectura con ReentrantReadWriteLock, qué es la «equidad» (modo fair), dónde es apropiada cada herramienta y qué errores aparecen con más frecuencia.

En esta lección veremos los primitivos clave de sincronización en Java: cómo proteger secciones críticas con synchronized y la clase ReentrantLock (métodos lock()/ unlock(), construcción try- finally), así como cómo limitar el paralelismo mediante Semaphore (métodos acquire()/ release()). Compararemos mutex y semáforo en una tabla, veremos casos prácticos (banco, servidor con límite de conexiones) y errores típicos que conducen a deadlock y a pérdidas de rendimiento.

Análisis práctico de errores frecuentes de concurrencia en Java: olvidar llamar a unlock()/ release() en ReentrantLock y Semaphore (se soluciona con try- finally), elegir un monitor incorrecto para synchronized, interbloqueos (deadlock) y el orden de adquisición de bloqueos, sincronización excesiva, así como los límites de aplicabilidad de volatile y la sustitución por AtomicInteger. Ejemplos, consejos y analogías claras — para que el código no «se quede bloqueado».