Lecciones

En la lección analizamos qué es el interbloqueo de hilos (deadlock) en Java, por qué ocurre y cuáles son las cuatro condiciones necesarias para que se produzca. Con un ejemplo práctico usando synchronized mostramos cómo reproducir el problema y luego estudiamos estrategias de prevención: orden único de adquisición de recursos, uso de ReentrantLock.tryLock con timeout, reducción de secciones críticas y evitar locks anidados innecesarios. Veremos la diagnosis mediante Thread Dump y jstack, cómo reconocer los estados BLOCKED/ WAITING, y cerraremos con una checklist y errores típicos.

Analizamos las anomalías de concurrencia Livelock y Starvation: en qué se diferencian de Deadlock, cómo se ven en el código y en los logs. Se muestran ejemplos en Java: «trabajadores corteses» (bloqueo vivo) e inanición por prioridades y debido a bloqueos injustos. Aprendemos a detectar el problema (registro de logs, Thread dump, VisualVM, Java Mission Control) y a prevenirlo: retrasos aleatorios antes de reintentar ( Thread.sleep), algoritmos no bloqueantes, bloqueos justos mediante ReentrantLock con el indicador fairness ( new ReentrantLock(true)), secciones críticas cuidadas y evitar abusar de setPriority() y synchronized.

En esta lección veremos por qué las colecciones normales ( ArrayList, HashMap) son peligrosas en un entorno multihilo y qué alternativas seguras para hilos ofrece el paquete java.util.concurrent: ConcurrentHashMap, CopyOnWriteArrayList, ConcurrentLinkedQueue, estructuras basadas en skip list y BlockingQueue. Hablaremos de operaciones atómicas como merge, putIfAbsent, computeIfAbsent, las compararemos con Collections.synchronizedMap, y veremos ejemplos prácticos y errores típicos (iteradores de consistencia débil, secuencias de operaciones no atómicas, etc.).

¿Por qué el incremento i ++ no funciona en multihilo, qué son las operaciones atómicas y cómo las ofrece el paquete java.util.concurrent.atomic. Analizamos AtomicInteger y AtomicReference, los métodos incrementAndGet(), compareAndSet(...), el mecanismo interno CAS (Compare-And-Swap), así como cuándo conviene elegir synchronized y cuándo — LongAdder. Al final — errores típicos: operaciones complejas, ABA y seguridad para hilos de objetos anidados.

Cómo capturar y leer un Thread Dump con jstack, VisualVM e IDE, reconocer los estados de los hilos ( RUNNABLE, BLOCKED, WAITING) y encontrar interbloqueos. Veremos la monitorización de hilos en Java Mission Control y Java Flight Recorder, prácticas de registro (nombres de hilos, entrada/salida de synchronized), minimización de bloqueos, pruebas de concurrencia con CountDownLatch y análisis de un caso real de deadlock. Al final — errores típicos y cómo evitarlos.

En esta lección analizamos la diferencia entre multihilo y paralelismo: dónde importa la capacidad de respuesta y dónde — la aceleración real en varios núcleos. Hablaremos de crear hilos mediante Thread, implementar Runnable y los pools de alto nivel ExecutorService, veremos un ejemplo sencillo de suma de un array, explicaremos cuándo el paralelismo ayuda y cuándo estorba, así como los problemas típicos: condiciones de carrera, sincronización mediante synchronized, interbloqueos y equilibrio de carga. Al final — una tabla comparativa y una visualización de escenarios.

Práctica de concurrencia de forma profesional: pasamos tareas a ExecutorService en lugar de crear Thread manualmente, gestionamos el pool, la cola y el ciclo de vida ( shutdown(), shutdownNow()). Analizamos la diferencia entre Runnable y Callable<T>, obtenemos resultados a través de Future y sus métodos ( get(), isDone(), cancel(...), isCancelled()). Mostraremos la ejecución de varias tareas, invokeAll/ invokeAny, el manejo de ExecutionException y errores típicos.

Entendemos cómo cambiar un flujo de datos secuencial a procesamiento en paralelo con una sola línea — mediante parallelStream() o .parallel(), qué ocurre bajo el capó en ForkJoinPool.commonPool(), cuándo la paralelización realmente acelera los cálculos (colecciones grandes, operaciones «pesadas») y dónde puede ralentizarlos. Mostraremos ejemplos de filtrado, agregación, ordenación, medición de rendimiento y analizaremos errores típicos: efectos secundarios en forEach, preservación del orden, elección de colecciones y configuración del grado de paralelismo.

Guía práctica de computación paralela en Java: cómo funciona el pool de tareas ForkJoinPool y las tareas recursivas RecursiveTask<T>/ RecursiveAction, por qué es útil el algoritmo de robo de trabajo (work-stealing), cómo dividir tareas con fork() y combinar resultados con join() dentro de compute(). Veremos el lanzamiento con pool.invoke(), un ejemplo de suma de un array y búsqueda del máximo, el papel de ForkJoinPool en parallelStream() y los errores típicos y cómo evitarlos.

Guía práctica de programación paralela en Java: cuándo conviene usar ExecutorService, dónde ayuda parallelStream y para qué tareas necesitas ForkJoinPool. Hablaremos de la seguridad de hilos con ConcurrentHashMap/ CopyOnWriteArrayList y clases atómicas ( AtomicInteger), mediciones de rendimiento con System.nanoTime() y JMH, gestión de errores desde Future.get() y ForkJoinTask, la reacción correcta a InterruptedException, así como técnicas de registro ( Thread.currentThread().getName()) y pruebas ( Awaitility). Al final — una tabla para elegir la herramienta y errores típicos.

Analizamos el arranque y la composición de cálculos asíncronos con CompletableFuture: cómo iniciar tareas mediante supplyAsync y runAsync, en qué se diferencian los manejadores thenApply, thenAccept, thenRun, y cuándo elegir sus variantes asíncronas thenApplyAsync/ thenAcceptAsync/ thenRunAsync. Hablaremos de los hilos de ejecución ( ForkJoinPool o tu Executor), de los tipos de resultados ( CompletableFuture<T>, CompletableFuture<Void>) y de errores típicos: llamadas bloqueantes get()/ join(), errores no gestionados sin exceptionally/ handle/ whenComplete, así como el intento de usar el resultado dentro de thenRun.