Aulas

Como paralelizar tarefas e unir resultados com CompletableFuture: combinação de dois resultados via thenCombine/ thenCombineAsync, espera de um conjunto de tarefas com allOf, reação à resposta mais rápida com anyOf. Vamos analisar as assinaturas, exemplos práticos com supplyAsync, processamento não bloqueante ( thenAccept, thenRun) e também nuances de erros e seu tratamento ( exceptionally, handle, whenComplete). No final — uma tabela compacta de comparação dos métodos.

Como capturar e tratar exceções com segurança em cadeias de CompletableFuture: entendemos os papéis de exceptionally (valor de fallback em caso de erro), handle (tratador universal de sucesso/erro) e whenComplete (efeitos colaterais sem alterar o resultado). Vamos discutir por que chamadas diretas a get()/ join() encapsulam a causa em ExecutionException/ CompletionException, como combinar etapas ( thenApply, thenAccept) e quais erros comuns evitar.

Como “encadear” corretamente etapas assíncronas em CompletableFuture com thenCompose e quando basta thenApply; como e por que usar um pool de threads próprio via ExecutorService (em vez de ForkJoinPool.commonPool()); como proteger cadeias contra “espera eterna” com orTimeout e completeOnTimeout. No final — um exemplo prático com Executor personalizado, thenCompose e timeout, além de erros típicos e suas soluções.

Nesta aula, analisamos entrada/saída assíncrona (AIO) no Java NIO.2: como ela difere do IO síncrono, como trabalhar com AsynchronousFileChannel, iniciar operações de leitura/gravação via Future e CompletionHandler, e como a escolha do pool de threads ExecutorService influencia. Na prática, veremos a abertura do canal com open, os métodos read/ write, o fluxo de interação e erros comuns.

Como, em Java, tratar a conclusão de operações assíncronas do NIO2: “promessas” com Future e callbacks com CompletionHandler. Veremos as assinaturas read/ write de AsynchronousFileChannel, a obtenção bloqueante do resultado com get() e a verificação com isDone(), além do tratamento não bloqueante em completed()/ failed(). Vamos mostrar exemplos práticos de leitura/gravação e uma breve comparação das abordagens.

Praticamos E/S assíncrona em Java: lemos grandes arquivos de texto em blocos no ByteBuffer via AsynchronousFileChannel, convertendo bytes em caracteres corretamente com CharsetDecoder, e gravamos os dados de volta de forma assíncrona (via Future ou CompletionHandler). Analisamos o problema da “quebra” de caracteres multibyte (por exemplo, "UTF-8"), contagem de linhas em tempo real, escolha de codificações e erros típicos ao trabalhar com buffers e canais.

Como capturar e tratar erros corretamente em I/O assíncrono no Java: callbacks CompletionHandler com os métodos completed/ failed, registro de logs e notificações. Examinamos o cancelamento de operações via Future e cancel( boolean), as consequências para get() e CancellationException, além de recomendações práticas: try-with-resources, sincronização com CountDownLatch/ CompletableFuture e liberação de recursos.

Análise prática dos pontos problemáticos ao trabalhar com E/S de arquivos assíncrona no Java NIO: gerenciamento correto de buffers ByteBuffer (propriedades position/ limit, chamadas flip(), clear(), compact()), condições de corrida em operações paralelas com AsynchronousFileChannel, fechamento de recursos ( channel.close(), try-with-resources), tratamento de erros em CompletionHandler (método failed(...)), controle do ciclo de vida das operações via Future<Integer> e sincronização com CountDownLatch, manuseio correto de codificações de caracteres por meio de CharsetDecoder, além da escolha de um pool de threads adequado com ExecutorService.

Vamos analisar em que os threads de plataforma diferem dos virtuais: como funciona o modelo “ Platform Thread → SO” e por que ele é pesado, o que muda com threads virtuais ( Virtual Thread) sobre carrier threads, e como isso traz escalabilidade sem “espaguete” reativo. Veremos na prática com Thread.ofVirtual(), compararemos o comportamento para tarefas I/O‑bound e CPU‑bound, tocaremos na compatibilidade (chamadas bloqueantes como InputStream.read, Socket.accept) e erros típicos (sincronizações antigas, expectativa de “aceleração mágica”).

Prática com threads virtuais do Java 21: em que elas diferem das threads de plataforma, como iniciar via Thread.startVirtualThread(...) e Thread.ofVirtual().start(...), quando ainda faz sentido usar new Thread(...) ou Thread.ofPlatform(), e como executar tarefas em massa com Executors.newVirtualThreadPerTaskExecutor(). Vamos ver a espera de término com join(), o tratamento de erros com Future e ExecutionException, bem como erros comuns ao usar Virtual Threads.

Comparação prática entre threads de plataforma Thread e threads virtuais do Java 21: como a JVM, graças aos “ portadores” (carrier threads), executa centenas de milhares de tarefas com uso mínimo de memória, onde os threads virtuais brilham (I/O-bound) e onde não (CPU-bound). Vamos analisar limitações ( synchronized, bloqueios nativos), melhores práticas ( Executors.newVirtualThreadPerTaskExecutor()), monitoramento via JVisualVM e Java Flight Recorder, bem como erros típicos ao migrar para Virtual Threads.

Vamos analisar como executar uma tarefa em uma thread virtual com Executors.newVirtualThreadPerTaskExecutor() (Java 21), em que isso difere dos pools clássicos ( newFixedThreadPool, newCachedThreadPool), como encerrar corretamente via shutdown() e awaitTermination(...), obter resultados de tarefas por meio de Future e onde as threads virtuais trazem o maior ganho (I/O em massa, servidores web, testes de carga). No final — erros típicos e nuances.