Aulas

Padrão comportamental “Observer”: papéis Subject e Observer, inscrição/cancelamento via addObserver/ removeObserver, e envio de notificações pelo método notifyObservers. Analisamos a relação com o modelo de eventos do Java: button. addActionListener( listener) ; → chamada de actionPerformed(). Prática com exemplos (termômetro e ar‑condicionado, mini‑contador e lambdas), além do motivo pelo qual java.util.Observable/ Observer estão obsoletos e quais são as abordagens modernas.

Nesta aula, veremos o que é a thread de despacho de eventos da UI — EDT no Swing e seu análogo JavaFX Application Thread, por que os componentes de interface não são thread-safe e por que a janela “trava” em tarefas pesadas. Mostraremos as práticas corretas: mover cálculos para segundo plano com new Thread(...), atualizar a interface com chamadas a SwingUtilities.invokeLater e Platform.runLater, além do uso de ferramentas de alto nível SwingWorker<T, V> e Task<V>/ Service<V> para progresso, cancelamento e tratamento de erros.

Por que programas precisam de threads e paralelismo: desde uma interface responsiva até ocupar todos os núcleos do processador. Vamos explicar a diferença entre processos e threads, o papel da thread principal main na JVM, casos práticos (UI, servidores, processamento de arquivos) e os riscos: race condition, deadlock, além de ferramentas básicas de sincronização como synchronized. Mostraremos um exemplo simples com Thread e a execução de duas tarefas em paralelo.

Nesta aula analisamos como iniciar threads em Java: conhecemos a classe Thread e a interface Runnable, aprendemos a chamar start() corretamente e a não confundi-lo com run(), usamos classes anônimas e expressões lambda, iniciamos várias threads e observamos o ciclo de vida ( NEW → RUNNABLE → TERMINATED). Falaremos sobre os métodos Thread.currentThread(), getName(), a espera com join() e erros típicos como IllegalThreadStateException.

Exploramos o ciclo de vida de uma thread em Java: de Thread.State (

NEW

,

RUNNABLE

,

BLOCKED

,

WAITING

,

TIMED_WAITING

,

TERMINATED

) até as transições entre eles. Aprendemos a gerenciar threads com Thread.sleep(...), join(), interrupt(), diagnosticar o estado por meio de isAlive() e getState(), bem como evitar métodos obsoletos como stop()/ suspend()/ resume(). No final — dicas práticas e erros comuns.

Como passar parâmetros com segurança para threads pelo construtor da classe que implementa Runnable, quando usar expressões lambda e por que é melhor tornar os campos final. Analisamos as prioridades de threads: métodos setPriority/ getPriority, constantes Thread.MIN_PRIORITY, Thread.NORM_PRIORITY, Thread.MAX_PRIORITY e seu efeito no escalonador. Além disso — nomear threads via construtor, setName/ getName, exemplo prático e erros típicos (um Runnable compartilhado, setters, confiar em prioridades).

Nesta aula explicamos o que é uma condição de corrida: quando várias threads acessam dados compartilhados simultaneamente e o resultado depende da ordem de escalonamento. Com o exemplo do incremento counter ++, mostramos por que a operação não é atômica e como incrementos se perdem. Analisamos um caso prático com uma conta bancária, as consequências em produção e abordagens de proteção: synchronized, tipos atômicos de java.util.concurrent.atomic (por exemplo, AtomicInteger), bem como a imutabilidade. Encerramos com a seção “Erros comuns”, onde se explica por que Thread-bugs raramente são pegos por testes e por que “tratar” isso com Thread. sleep( 1) é inútil.

Esta aula é sobre o que é um recurso compartilhado em aplicações multithread, por que surgem condições de corrida (race condition) e “atualizações perdidas”, e como proteger os dados com synchronized. Vamos analisar técnicas básicas de sincronização (métodos e blocos), falar sobre ferramentas modernas de java.util.concurrent ( Lock, ReentrantLock, Semaphore etc.), ver exemplos práticos com incremento de contador e erros típicos (não atomicidade de i ++, objeto de bloqueio incorreto, mitos sobre volatile).

Aula prática sobre multithreading: analisamos como funciona a palavra‑chave synchronized (blocos e métodos, monitor do objeto e bloqueio no nível da classe ClassName.class), qual é a diferença entre a visibilidade de alterações via volatile e a atomicidade das operações, por que é conveniente usar flags boolean como volatile, e por que o incremento count ++ requer sincronização. Vamos comparar quando escolher synchronized e quando — volatile, e revisar erros comuns.

Comparação prática da sincronização clássica por meio de synchronized com primitivos mais flexíveis do pacote java.util.concurrent.locks: ReentrantLock e ReadWriteLock. Vamos ver como controlar bloqueios explicitamente ( lock()/ unlock(), tryLock() com timeout), como escalar leitura com ReentrantReadWriteLock, o que é “justiça” ( fair mode), onde cada ferramenta é apropriada e quais erros ocorrem com mais frequência.

Nesta aula, vamos analisar os principais primitivos de sincronização em Java: como proteger seções críticas com synchronized e a classe ReentrantLock (métodos lock()/ unlock(), construção try- finally), e também como limitar o paralelismo com Semaphore (métodos acquire()/ release()). Vamos comparar mútex e semáforo em uma tabela, considerar casos práticos (banco, servidor com limite de conexões) e erros típicos que levam a deadlock e perdas de desempenho.

Análise prática de erros frequentes de concorrência em Java: unlock()/ release() esquecido em ReentrantLock e Semaphore (resolve-se com try- finally), escolha do monitor errado para synchronized, bloqueios mútuos (deadlock) e a ordem de aquisição dos locks, sincronização excessiva, além dos limites de uso de volatile e a substituição por AtomicInteger. Exemplos, dicas e analogias claras — para que o código não “trave de vez”.