Lecciones

Cómo paralelizar tareas y combinar resultados con CompletableFuture: combinar dos resultados con thenCombine/ thenCombineAsync, esperar a un conjunto de tareas con allOf, reaccionar a la respuesta más rápida con anyOf. Veremos las firmas, ejemplos prácticos con supplyAsync, el procesamiento no bloqueante ( thenAccept, thenRun), así como los matices de los errores y su manejo ( exceptionally, handle, whenComplete). Al final — una tabla compacta de comparación de métodos.

Cómo capturar y manejar excepciones de forma segura en cadenas CompletableFuture: analizamos los roles de exceptionally (valor de reserva en caso de error), handle (manejador universal de éxito/error) y whenComplete (acciones colaterales sin cambiar el resultado). Comentaremos por qué la invocación directa de get()/ join() envuelve las causas en ExecutionException/ CompletionException, cómo combinar etapas ( thenApply, thenAccept) y qué errores típicos evitar.

Cómo «encadenar» correctamente los pasos asíncronos en CompletableFuture con thenCompose y cuándo basta con thenApply; cómo y por qué conectar un pool de hilos propio mediante ExecutorService (en lugar de ForkJoinPool.commonPool()); cómo proteger las cadenas de un «esperar para siempre» con orTimeout y completeOnTimeout. Al final — un ejemplo práctico con un Executor personalizado, thenCompose y tiempo de espera, así como errores típicos y sus soluciones.

En esta lección analizamos la entrada/salida asíncrona (AIO) en Java NIO.2: en qué se diferencia de la E/S síncrona, cómo trabajar con AsynchronousFileChannel, lanzar operaciones de lectura/escritura mediante Future y CompletionHandler, y cómo influye la elección del pool de hilos ExecutorService. En la práctica veremos la apertura del canal con open, los métodos read/ write, el esquema de interacción y los errores frecuentes.

Cómo gestionar en Java la finalización de operaciones asíncronas de NIO2: «promesas» mediante Future y devoluciones de llamada mediante CompletionHandler. Veremos las firmas de read/ write en AsynchronousFileChannel, la obtención bloqueante del resultado con get() y la consulta con isDone(), así como el manejo no bloqueante en completed()/ failed(). Mostraremos ejemplos prácticos de lectura/escritura y una comparación breve de los enfoques.

Practicamos E/S asíncrona en Java: leemos archivos de texto grandes por bloques en ByteBuffer mediante AsynchronousFileChannel, convertimos los bytes en caracteres correctamente con CharsetDecoder, y escribimos los datos de vuelta de forma asíncrona (con Future o CompletionHandler). Abordamos el problema de la «rotura» de caracteres multibyte (por ejemplo, "UTF-8"), el recuento de líneas al vuelo, la elección de codificaciones y los errores típicos al trabajar con buffers y canales.

Cómo capturar y manejar correctamente los errores en la entrada/salida asíncrona de Java: callbacks CompletionHandler con los métodos completed/ failed, registro de logs y notificaciones. Analizamos la cancelación de operaciones mediante Future y cancel( boolean), sus efectos en get() y CancellationException, así como consejos prácticos: try-with-resources, sincronización con CountDownLatch/ CompletableFuture y liberación de recursos.

Análisis práctico de las trampas al trabajar con la E/S de archivos asíncrona en Java NIO: gestión correcta de los buffers ByteBuffer (propiedades position/ limit, llamadas a flip(), clear(), compact()), condiciones de carrera en operaciones paralelas con AsynchronousFileChannel, cierre de recursos ( channel.close(), try-with-resources), gestión de errores en CompletionHandler (método failed(...)), gestión del ciclo de vida de las operaciones mediante Future<Integer> y sincronización con CountDownLatch, manejo correcto de codificaciones mediante CharsetDecoder, así como elección del pool de hilos adecuado ExecutorService.

Desgranamos en qué se diferencian los hilos de plataforma de los virtuales: cómo funciona el modelo « Platform Thread → SO» y por qué es pesado, qué cambia con los hilos virtuales ( Virtual Thread) sobre carrier threads, y cómo eso aporta escalabilidad sin «espagueti» reactivo. Veremos la práctica con Thread.ofVirtual(), compararemos el comportamiento para tareas I/O‑bound y CPU‑bound, trataremos la compatibilidad (llamadas bloqueantes como InputStream.read, Socket.accept) y los errores típicos (sincronizaciones antiguas, esperar una «aceleración mágica»).

Práctica con los hilos virtuales de Java 21: en qué se diferencian de los de plataforma, cómo iniciarlos mediante Thread.startVirtualThread(...) y Thread.ofVirtual().start(...), cuándo sigue siendo adecuado new Thread(...) o Thread.ofPlatform(), y cómo ejecutar tareas en masa con Executors.newVirtualThreadPerTaskExecutor(). Veremos la espera de finalización con join(), el manejo de errores con Future y ExecutionException, así como los errores típicos al usar hilos virtuales.

Comparación práctica entre hilos de plataforma Thread y hilos virtuales de Java 21: cómo la JVM, gracias a los « portadores» (carrier threads), ejecuta cientos de miles de tareas con un uso mínimo de memoria; dónde los hilos virtuales brillan (I/O‑bound) y dónde no (CPU‑bound). Veremos las limitaciones ( synchronized, bloqueos nativos), las mejores prácticas ( Executors.newVirtualThreadPerTaskExecutor()), la monitorización con JVisualVM y Java Flight Recorder, así como los errores típicos al migrar a Virtual Threads.

Analizamos cómo ejecutar una tarea en un hilo virtual con Executors.newVirtualThreadPerTaskExecutor() (Java 21), en qué se diferencia de los pools clásicos ( newFixedThreadPool, newCachedThreadPool), cómo cerrar correctamente con shutdown() y awaitTermination(...), cómo obtener resultados de las tareas mediante Future y dónde los hilos virtuales proporcionan la mayor ventaja (I/O masivo, servidores web, pruebas de carga). Al final — errores típicos y matices.