Como funciona o multithreading em Java?

Question

Accepted Answer

**Multithreading** permite que um programa Java execute múltiplas threads simultaneamente, possibilitando paralelismo (uso de múltiplos núcleos de CPU) e responsividade (fazer trabalho sem bloqueio). Java tem suporte a threads de primeira classe — mas estado mutável compartilhado introduz complexidade (race conditions) que deve ser gerenciada cuidadosamente. ## Criando threads ```java // 1. Implement Runnable (preferred — separates task from thread) Runnable task = () -> System.out.println("running on " + Thread.currentThread().getName()); Thread t = new Thread(task); t.start(); // start() runs it on a NEW thread (run() would run on the CURRENT thread!) // 2. modern: use an ExecutorService instead of raw threads ExecutorService executor = Executors.newFixedThreadPool(4); executor.submit(task); ``` **Armadilha principal:** chame `start()` (gera uma nova thread), não `run()` (que apenas executa o código na thread atual sincronamente). ## O problema central: race conditions ```java // ❌ multiple threads modifying shared state → unpredictable results class Counter { int count = 0; void increment() { count++; } // NOT atomic: read → add → write (can interleave) } // 1000 threads each incrementing 1000 times → final count is often < 1,000,000! ``` `count++` na verdade são três operações (ler, incrementar, escrever). Quando threads se intercalam, as atualizações se perdem — uma **race condition**. Este é o desafio central da concorrência: estado mutável compartilhado acessado por múltiplas threads sem coordenação. ## Soluções para estado compartilhado seguro ```java // 1. synchronized — only one thread in the method/block at a time (a lock) synchronized void increment() { count++; } // 2. atomic classes — lock-free atomic operations AtomicInteger count = new AtomicInteger(0); count.incrementAndGet(); // atomic, thread-safe, efficient // 3. concurrent collections — built for multi-threaded access ConcurrentHashMap map = new ConcurrentHashMap<>(); // 4. immutability — immutable objects are inherently thread-safe (nothing to corrupt) ``` ## Coordenação de threads ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## A abordagem moderna: não gerencie threads brutos ```text ✓ Use ExecutorService / thread pools (not new Thread() per task — expensive) ✓ Use CompletableFuture for async composition ✓ Use concurrent collections and atomic classes over manual synchronization ✓ Java 21+ adds Virtual Threads — millions of lightweight threads for I/O concurrency ``` ## Por que isso importa Multithreading permite que programas Java usem múltiplos núcleos e permaneçam responsivos, mas também é uma das áreas mais difíceis de acertar — **race conditions** de estado mutável compartilhado não sincronizado causam bugs intermitentes e difíceis de reproduzir. Compreender como threads funcionam (`start()` vs `run()`), o problema central de race conditions (por que `count++` não é seguro) e as ferramentas para garantir segurança (`synchronized`, classes atômicas, coleções concorrentes, imutabilidade) é essencial para escrever código concorrente correto. A prática moderna favorece abstrações de nível superior (ExecutorService, CompletableFuture, threads virtuais) em vez de gerenciamento de threads brutos. Este é conhecimento crítico para Java do lado do servidor e de alto desempenho, e um tópico profundo e frequentemente testado que separa desenvolvedores competentes de experts.