Aulas

Nesta aula explicamos o que é o bloqueio mútuo de threads (deadlock) em Java, por que ele acontece e quais são as quatro condições necessárias para ocorrer. Com um exemplo prático usando synchronized mostramos como reproduzir o problema e, em seguida, estudamos estratégias de prevenção: ordem única de aquisição de recursos, uso de ReentrantLock.tryLock com timeout, redução de seções críticas e evitar locks aninhados desnecessários. Mostramos a diagnose via Thread Dump e jstack, como reconhecer os estados BLOCKED/ WAITING, e encerramos com um checklist e erros típicos.

Analisamos as anomalias de concorrência Livelock e Starvation: em que diferem de Deadlock, como aparecem no código e nos logs. São mostrados exemplos em Java: “trabalhadores educados” (bloqueio vivo) e fome por prioridades e por bloqueios injustos. Aprendemos a detectar o problema (registro em log, Thread dump, VisualVM, Java Mission Control) e a preveni‑lo: atrasos aleatórios antes de nova tentativa ( Thread.sleep), algoritmos não bloqueantes, bloqueios justos via ReentrantLock com o sinalizador fairness ( new ReentrantLock(true)), seções críticas cuidadosas e evitar abusar de setPriority() e synchronized.

Nesta aula, vamos analisar por que coleções comuns ( ArrayList, HashMap) são perigosas em ambiente multithread e quais alternativas thread-safe o pacote java.util.concurrent oferece: ConcurrentHashMap, CopyOnWriteArrayList, ConcurrentLinkedQueue, estruturas com skip list e BlockingQueue. Discutiremos operações atômicas como merge, putIfAbsent, computeIfAbsent, vamos comparar com Collections.synchronizedMap, e considerar exemplos práticos e erros típicos (iteradores fracamente consistentes, sequências de operações não atômicas etc.).

Por que o incremento i ++ não funciona em ambiente multithread, o que são operações atômicas e como o pacote java.util.concurrent.atomic as fornece. Analisamos AtomicInteger e AtomicReference, os métodos incrementAndGet(), compareAndSet(...), o mecanismo interno CAS (Compare-And-Swap), e também quando é melhor escolher synchronized e quando — LongAdder. No final — erros típicos: operações complexas, ABA e a segurança de thread de objetos aninhados.

Como capturar e ler Thread Dump com jstack, VisualVM e a IDE, reconhecer estados de threads ( RUNNABLE, BLOCKED, WAITING) e encontrar deadlocks. Vamos abordar o monitoramento de threads no Java Mission Control e no Java Flight Recorder, práticas de logging (nomes de threads, entrada/saída de synchronized), minimização de locks, testes de concorrência com CountDownLatch e a análise de um caso real de deadlock. No final — erros típicos e como evitá-los.

Nesta aula, analisamos a diferença entre multithreading e paralelismo: onde importa a responsividade e onde há aceleração real em vários núcleos. Vamos discutir a criação de threads por meio de Thread, a implementação de Runnable e pools de alto nível ExecutorService, ver um exemplo simples de soma de um array, entender quando o paralelismo ajuda e quando atrapalha, bem como problemas típicos: condições de corrida, sincronização com synchronized, deadlocks e balanceamento de carga. No fim — uma tabela comparativa e uma visualização de cenários.

Prática de multithreading de verdade: enviamos tarefas para o ExecutorService em vez de criar Thread manualmente, gerenciamos o pool, a fila e o ciclo de vida ( shutdown(), shutdownNow()). Analisamos a diferença entre Runnable e Callable<T>, obtemos resultados via Future e seus métodos ( get(), isDone(), cancel(...), isCancelled()). Mostraremos a execução de várias tarefas, invokeAll/ invokeAny, o tratamento de ExecutionException e erros comuns.

Entenda como alternar um fluxo de dados sequencial para processamento paralelo com uma única linha — usando parallelStream() ou .parallel(), o que acontece por baixo dos panos em ForkJoinPool.commonPool(), quando o paralelismo realmente acelera os cálculos (coleções grandes, operações “pesadas”) e onde ele pode até atrasar. Mostraremos exemplos de filtragem, agregação, ordenação, medição de desempenho e analisaremos erros típicos: efeitos colaterais em forEach, preservação de ordem, escolha de coleções e configuração do grau de paralelismo.

Guia prático de computação paralela em Java: como funciona o pool de tarefas ForkJoinPool e as tarefas recursivas RecursiveTask<T>/ RecursiveAction, por que o algoritmo de work-stealing é útil, como dividir tarefas com fork() e combinar resultados com join() dentro de compute(). Veremos a execução via pool.invoke(), um exemplo de soma de array e busca do máximo, o papel de ForkJoinPool em parallelStream(), além de erros típicos e como evitá-los.

Guia prático de programação paralela em Java: quando usar ExecutorService, onde parallelStream ajuda e para quais tarefas é necessário ForkJoinPool. Vamos discutir segurança de thread com ConcurrentHashMap/ CopyOnWriteArrayList e classes atômicas ( AtomicInteger), medições de desempenho via System.nanoTime() e JMH, tratamento de erros de Future.get() e ForkJoinTask, reação correta a InterruptedException, bem como técnicas de logging ( Thread.currentThread().getName()) e de testes ( Awaitility). No final — uma tabela de escolha de ferramenta e erros típicos.

Vamos analisar a inicialização e a composição de computações assíncronas com CompletableFuture: como iniciar tarefas via supplyAsync e runAsync, em que os handlers thenApply, thenAccept, thenRun diferem, e quando escolher suas versões assíncronas thenApplyAsync/ thenAcceptAsync/ thenRunAsync. Vamos falar sobre threads de execução ( ForkJoinPool ou seu Executor), tipos de resultados ( CompletableFuture<T>, CompletableFuture<Void>) e erros típicos: chamadas bloqueantes get()/ join(), erros não tratados sem exceptionally/ handle/ whenComplete, bem como a tentativa de usar o resultado dentro de thenRun.