Lecciones

Analizamos por qué el clásico ThreadLocal pierde relevancia en el mundo de los hilos virtuales y cómo lo sustituye ScopedValue: un contexto ligado al ámbito de ejecución y no al hilo. Ejemplos paso a paso de propagación de contexto (usuario, REQUEST_ID), scopes anidados y su superposición, integración con hilos virtuales ( Executors. newVirtualThreadPerTaskExecutor()). Hablamos de la comparación ThreadLocal vs ScopedValue, consejos prácticos, limitaciones y una mirada a Structured Concurrency (preview).

Structured Concurrency convierte un conjunto caótico de hilos en una jerarquía de tareas controlada: lanzas subtareas en hilos virtuales dentro de StructuredTaskScope, esperas a través de join(), gestionas los errores de forma centralizada con throwIfFailed() y obtienes resultados con resultNow()/ result(). Veremos las políticas de finalización ShutdownOnFailure y ShutdownOnSuccess, las compararemos con CompletableFuture, veremos ejemplos de un agregador HTTP y errores típicos al usar la concurrencia estructurada.

Cómo cancelar correctamente operaciones largas y bloqueantes en Java: interrupción cooperativa mediante Thread.interrupt(), cancelación de tareas con Future.cancel() y el comportamiento de CancellationException, tiempos de espera y cancelación en CompletableFuture ( orTimeout, completeOnTimeout), concurrencia estructurada con StructuredTaskScope, plazo común (time‑budget) y propagación de tiempos de espera hacia abajo por la pila (incluidos Instant/ Duration y Scoped Values). Revisamos la práctica con IO bloqueante y errores típicos.

En esta lección analizamos los sincronizadores de alto nivel de java.util.concurrent: CountDownLatch, CyclicBarrier, Phaser y Exchanger. Aprendemos a coordinar el arranque y la finalización de tareas mediante await()/ countDown(), a construir fases reutilizables y acciones de barrera con await(), a gestionar participantes dinámicos de la «orquesta» con register()/ arriveAndAwaitAdvance()/ arriveAndDeregister() y a intercambiar datos por parejas con exchange(). En la práctica implementaremos una salida masiva de hilos de trabajo y un «tick» de juego, y también veremos errores típicos: la condición de un solo uso de CountDownLatch, el manejo de BrokenBarrierException y un deregister() correcto. En todos los casos, sin el dolor de wait()/ notify().

Cuando ReentrantReadWriteLock y el clásico ReadWriteLock empiezan a atascarse bajo alta carga, entra en juego StampedLock con lectura optimista: la pareja tryOptimisticRead + validate proporciona lecturas casi «gratuitas» cuando las escrituras son poco frecuentes. Analizaremos los modos de bloqueo, el trabajo con stamps, las limitaciones de reentrancy, lo compararemos con ReentrantReadWriteLock, y además veremos contadores de baja contención — LongAdder y LongAccumulator — y por qué superan a AtomicLong bajo contención. Cerraremos con práctica: una caché con predominio de lectura y un mini-benchmark.

Analizamos las reglas de visibilidad y orden en Java Memory Model: qué significa la relación happens-before, cómo y cuándo ayudan volatile, synchronized, los campos finales ( final), y por qué sin ellos aparecen datos «desactualizados». Mostraremos la publicación segura de objetos, un double-checked locking correcto, el acceso de bajo nivel mediante VarHandle, la influencia del false sharing y la anotación @Contended, así como observaciones prácticas sobre Thread.start()/ Thread.join(), Future.get() y los microbenchmarks JMH.

Guía práctica sobre el trabajo paralelo con archivos en Java: cuándo el multihilo realmente acelera la E/S y cuándo no, elección de herramientas — Thread, pool de hilos mediante ExecutorService, asincronía con CompletableFuture y streams paralelos — así como lectura de archivos grandes por partes con FileChannel, escritura segura en un log compartido y limitaciones del SO/SF. Analizamos patrones de lanzamiento de tareas, configuración de pools, los métodos shutdown()/ awaitTermination() y errores típicos.

Guía práctica para paralelizar tareas de archivos en Java: cómo habilitar el paralelismo en la API de Stream con el método parallel()/ parallelStream(), cómo funciona y se configura ForkJoinPool y cuándo es mejor utilizar RecursiveTask. Comentaremos dónde el paralelismo realmente acelera la E/S, cómo gestionar el pool común de hilos y cómo cerrar recursos de forma segura ( try-with-resources). Al final — una mirada rápida al acceso posicional mediante FileChannel para leer/escribir partes de archivos grandes.

Cómo acelerar el recorrido de directorios grandes y el procesamiento de miles de archivos: usamos Files.walk() y streams paralelos mediante parallel(), entendemos el papel de ForkJoinPool.commonPool() y configuramos el grado de paralelismo. Analizamos cuándo conviene pasar a ExecutorService, en qué se diferencian las tareas CPU-bound e IO-bound, escribimos un ejemplo para contar líneas en todos los archivos ".java" y fijamos las mejores prácticas.

Cómo acelerar el procesamiento de archivos de gigabytes: los dividimos en chunks (chunking), usamos acceso posicional mediante FileChannel y buffers mapeados en memoria MappedByteBuffer, paralelizamos el cómputo con ExecutorService. Veremos los métodos clave de E/S posicional: position(...), read(...), write(...), criterios para elegir el tamaño del chunk, un ejemplo de conteo de palabras en paralelo y errores típicos (límites de los chunks, recursos, cantidad de hilos).

Analizamos cómo organizar una canalización de procesamiento de archivos siguiendo el patrón Producer–Consumer con intercambio seguro mediante BlockingQueue (por ejemplo, ArrayBlockingQueue), cómo funcionan las operaciones bloqueantes put() y take(), para qué sirve el mecanismo de backpressure y cómo finalizar correctamente los hilos con una «poison pill» (por ejemplo, "__END__", y no null). Lanzamos los consumidores mediante ExecutorService, añadimos una visualización de la canalización y revisamos errores típicos.

Analizamos por qué Java 9 trajo el sistema de módulos JPMS: qué tiene de malo la « classpath-party», cómo los módulos introducen límites de visibilidad a nivel de contenedor, qué es module-info.java y cómo trabajar con las directivas module, exports, requires, opens, uses/ provides. Hablaremos de las ventajas (encapsulación, dependencias explícitas, seguridad, jlink), los ámbitos de aplicación (incluyendo java.base, java.sql), detalles útiles y errores típicos durante la migración (olvido de exports, omisión de requires, duplicación de nombres de módulos).