Aulas

Explicamos por que o clássico ThreadLocal perde relevância no mundo das threads virtuais e como ele dá lugar ao ScopedValue: um contexto vinculado ao escopo de execução, e não à thread. Exemplos passo a passo de passagem de contexto (usuário, REQUEST_ID), escopos aninhados e sua sobreposição, integração com threads virtuais ( Executors. newVirtualThreadPerTaskExecutor()). Discutimos a comparação ThreadLocal vs ScopedValue, dicas práticas, limitações e uma visão sobre Structured Concurrency (preview).

Structured Concurrency transforma um conjunto caótico de threads em uma hierarquia controlada de tarefas: você inicia subtarefas em threads virtuais dentro de StructuredTaskScope, espera por elas com join(), trata erros de forma centralizada com throwIfFailed() e obtém resultados com resultNow()/ result(). Vamos analisar as políticas de término ShutdownOnFailure e ShutdownOnSuccess, comparar com CompletableFuture, ver exemplos de um agregador HTTP e erros típicos ao usar concorrência estruturada.

Como cancelar corretamente operações longas e bloqueantes em Java: interrupção cooperativa via Thread.interrupt(), cancelamento de tarefas via Future.cancel() e o comportamento de CancellationException, timeouts e cancelamento em CompletableFuture ( orTimeout, completeOnTimeout), concorrência estruturada com StructuredTaskScope, deadline comum (time‑budget) e propagação de timeouts para baixo na pilha (incluindo Instant/ Duration e Scoped Values). Analisamos a prática de trabalhar com IO bloqueante e erros típicos.

Na aula, analisamos os sincronizadores de alto nível de java.util.concurrent: CountDownLatch, CyclicBarrier, Phaser e Exchanger. Aprendemos a coordenar o início e o término de tarefas via await()/ countDown(), construir fases reutilizáveis e ações de barreira com await(), gerenciar participantes dinâmicos da “orquestra” com register()/ arriveAndAwaitAdvance()/ arriveAndDeregister() e trocar dados em pares por meio de exchange(). Na prática, implementamos uma largada em massa de workers e um “tick” de jogo, e também abordamos erros típicos: uso único do CountDownLatch, tratamento de BrokenBarrierException e deregister() correto. Em todos os casos, evitamos a dor de wait()/ notify().

Quando ReentrantReadWriteLock e o ReadWriteLock clássico começam a patinar sob alta carga, entra em cena o StampedLock com leitura otimista: a dupla tryOptimisticRead + validate oferece leituras praticamente “de graça” quando as escritas são raras. Vamos analisar os modos de bloqueio, o trabalho com selos, as limitações de reentrância, comparar com ReentrantReadWriteLock e também ver contadores de baixa contenção — LongAdder e LongAccumulator — e por que eles superam o AtomicLong sob contenção. Terminaremos com prática: cache com predominância de leitura e um mini-benchmark.

Analisamos as regras de visibilidade e ordenação de operações no Java Memory Model: o que significa a relação happens-before, como e quando ajudam volatile, synchronized, campos finais ( final) e por que sem eles surgem dados “obsoletos”. Mostraremos a publicação segura de objetos, o double-checked locking correto, acesso de baixo nível via VarHandle, o impacto de false sharing e a anotação @Contended, bem como observações práticas sobre Thread.start()/ Thread.join(), Future.get() e microbenchmarks com JMH.

Guia prático para trabalho paralelo com arquivos em Java: quando o multithreading realmente acelera IO e quando não, escolha de ferramentas — Thread, pool de threads via ExecutorService, assincronicidade com CompletableFuture e streams paralelos — além de leitura de arquivos grandes em partes com FileChannel, gravação segura em um log compartilhado e limitações do SO/sistema de arquivos. Analisamos padrões de disparo de tarefas, ajustes de pools, métodos shutdown()/ awaitTermination() e erros típicos.

Guia prático de paralelização de tarefas de arquivos em Java: como habilitar paralelismo na Stream API com os métodos parallel()/ parallelStream(), como o ForkJoinPool funciona e é configurado, e quando é melhor usar RecursiveTask. Vamos discutir onde o paralelismo realmente acelera I/O, como gerenciar o pool comum de threads e como fechar recursos com segurança ( try-with-resources). Por fim — um olhar rápido sobre o acesso posicional via FileChannel para leitura/gravação de partes de arquivos grandes.

Como acelerar o percurso de diretórios grandes e o processamento de milhares de arquivos: usamos Files.walk() e streams paralelos via parallel(), entendemos o papel de ForkJoinPool.commonPool() e ajustamos o grau de paralelismo. Vemos quando é melhor migrar para ExecutorService, o que diferencia tarefas CPU-bound e IO-bound, escrevemos um exemplo de contagem de linhas em todos os arquivos ".java" e consolidamos boas práticas.

Como acelerar o processamento de arquivos de gigabytes: dividimos em chunks (chunking), usamos acesso posicional via FileChannel e buffers mapeados em memória MappedByteBuffer, paralelizamos o processamento com ExecutorService. Vamos revisar os métodos-chave de E/S posicional: position(...), read(...), write(...), critérios para escolher o tamanho do chunk, um exemplo de contagem paralela de palavras e erros típicos (fronteiras de chunks, recursos, quantidade de threads).

Vamos analisar como organizar um pipeline de processamento de arquivos com o padrão Producer–Consumer, com troca segura via BlockingQueue (por exemplo, ArrayBlockingQueue), como funcionam as operações bloqueantes put() e take(), por que é necessário o mecanismo de backpressure e como encerrar corretamente as threads usando a “poison pill” (por exemplo, "__END__", e não null). Iniciamos os consumidores via ExecutorService, adicionamos uma visualização do pipeline e analisamos erros típicos.

Vamos analisar por que o Java 9 trouxe o sistema de módulos JPMS: o que há de errado com a “classpath party”, como os módulos introduzem limites de visibilidade no nível do contêiner, o que é o module-info.java e como trabalhar com as diretivas module, exports, requires, opens, uses/ provides. Vamos discutir as vantagens (encapsulamento, dependências explícitas, segurança, jlink), onde aplicar (incluindo java.base, java.sql), nuances úteis e erros típicos na migração (um exports esquecido, um requires omitido, nomes de módulos duplicados).