1. Por que i++ não funciona em ambiente multithread?
Vamos começar com um caso clássico: temos uma variável‑contador, por exemplo, a quantidade de solicitações processadas ou o número de arquivos baixados. Queremos que vários threads incrementem esse contador. O que pode dar errado se simplesmente escrever i++?
Exemplo: condição de corrida no incremento
public class Counter {
public int count = 0;
public void increment() {
count++; // Não é atômico!
}
}
Vamos supor que duas threads chamem increment() ao mesmo tempo. Ambas leem o valor antigo, ambas o aumentam em 1, e ambas gravam… o mesmo novo valor! Como resultado, um incremento se “perde”. Se repetir isso muitas vezes, o valor final será menor do que o esperado.
Por que isso acontece?
A operação i++ na verdade consiste em três etapas:
- Ler o valor da variável (por exemplo, 5).
- Incrementar esse valor em 1.
- Gravar o novo valor de volta na memória.
E em um ambiente multithread outra thread pode conseguir alterar a variável entre essas etapas. Resultado — uma “condição de corrida” (race condition).
O que são operações atômicas?
Uma operação atômica é uma ação que ou é executada completamente ou não é executada, e nenhuma outra thread pode “interferir” no meio dessa operação.
No Java há um conjunto de classes que fornecem tais operações para primitivos e referências. Elas estão no pacote java.util.concurrent.atomic. As mais populares:
- AtomicInteger — tipo inteiro atômico.
- AtomicLong — long atômico.
- AtomicBoolean — boolean atômico.
- AtomicReference<T> — referência atômica para um objeto de qualquer tipo.
2. AtomicInteger: contador thread‑safe
Declaração e uso básico
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicCounter {
private final AtomicInteger count = new AtomicInteger(0);
public void increment() {
count.incrementAndGet(); // Incremento atômico
}
public int get() {
return count.get();
}
}
Aqui, incrementAndGet() executa “incrementar e retornar o novo valor” como uma única operação indivisível. Mesmo que 100 threads chamem esse método ao mesmo tempo, nenhum incremento será perdido.
Métodos úteis:
| Método | Descrição |
|---|---|
|
Obter o valor atual |
|
Definir o valor |
|
Incrementar em 1 e retornar o novo valor |
|
Retornar o valor atual e incrementar em 1 |
|
Incrementar em delta e retornar o novo valor |
|
Se o valor atual for igual a expect, definir update (CAS) |
Exemplo: contador multithread
Suponha que temos uma classe que conta a quantidade de mensagens processadas em um chat.
public class MessageStatistics {
private final AtomicInteger messageCount = new AtomicInteger(0);
public void onMessageReceived() {
int newCount = messageCount.incrementAndGet();
System.out.println("Total de mensagens: " + newCount);
}
public int getMessageCount() {
return messageCount.get();
}
}
Por dentro: como o AtomicInteger funciona?
Internamente, o AtomicInteger usa uma instrução especial do processador — CAS (Compare-And-Swap, “comparar‑e‑substituir”). É uma operação atômica que compara o valor atual da variável com o esperado e, se eles coincidirem, grava o novo valor. Se outra thread tiver conseguido alterar a variável, a operação não é executada e a tentativa é repetida.
Esquema de funcionamento:
1. Lemos o valor atual (por exemplo, 5)
2. Comparamos com o esperado (5)
3. Se corresponder — gravamos o novo valor (6)
4. Se não corresponder — repetimos a tentativa
Tudo isso acontece muito rapidamente e sem bloqueios (lock‑free). Por isso, as classes atômicas costumam ser mais rápidas do que synchronized, especialmente com um grande número de threads.
3. AtomicReference: referência atômica para um objeto
AtomicReference<T> é um contêiner atômico genérico para qualquer objeto. Ele permite alterar a referência ao objeto com segurança a partir de diferentes threads.
Exemplo: atualização de referência thread‑safe
import java.util.concurrent.atomic.AtomicReference;
public class AtomicReferenceExample {
private final AtomicReference<String> latestMessage = new AtomicReference<>("");
public void updateMessage(String message) {
latestMessage.set(message);
}
public String getLatestMessage() {
return latestMessage.get();
}
}
Uso de compareAndSet
A operação mais interessante é compareAndSet(expected, newValue). Ela permite atualizar o valor somente se ele não tiver mudado desde a última leitura.
public void safeUpdate(String oldValue, String newValue) {
boolean success = latestMessage.compareAndSet(oldValue, newValue);
if (success) {
System.out.println("Atualização concluída com sucesso!");
} else {
System.out.println("Alguém já alterou o valor, tente novamente.");
}
}
Essa é a base de algoritmos não bloqueantes: de filas e pilhas a caches, onde é importante evitar bloqueios desnecessários.
4. Exemplos de uso em uma aplicação
Exemplo 1: contador de mensagens multithread
public class ChatRoom {
private final AtomicInteger messageCount = new AtomicInteger(0);
public void receiveMessage(String message) {
// ... processamento da mensagem ...
int count = messageCount.incrementAndGet();
System.out.println("Nova mensagem: " + message + ". Total de mensagens: " + count);
}
}
Exemplo 2: atualização segura da referência para a última mensagem
public class ChatRoom {
private final AtomicReference<String> lastMessage = new AtomicReference<>("");
public void receiveMessage(String message) {
lastMessage.set(message);
// ... processamento ...
}
public String getLastMessage() {
return lastMessage.get();
}
}
Se for necessário atualizar a referência apenas se a última mensagem não tiver mudado (para evitar “perdas” em atualizações simultâneas), use compareAndSet.
5. Limitações e armadilhas
Quando as classes atômicas não são panaceia?
Variáveis atômicas são ótimas para operações simples: incremento, definição de valor, verificar e substituir. Mas se for preciso atualizar várias variáveis ao mesmo tempo, a atomicidade já não é garantida. Por exemplo, se você tem dois contadores e quer incrementar ambos como uma única operação — aqui é necessário synchronized ou outro mecanismo de sincronização.
Exemplo de uso incorreto
// NÃO é atômico!
if (ref.get() == null) {
ref.set("Hello");
}
Entre get() e set(...) outra thread pode alterar o valor, e a condição já não será verdadeira. Para tais casos, use compareAndSet.
Classes atômicas ≠ objetos thread‑safe
Se o objeto apontado por AtomicReference não for thread‑safe, a troca da referência será atômica, mas a alteração dos campos do objeto — não. Por exemplo, se você armazena em AtomicReference<List<String>> um ArrayList comum, a lista em si não se torna thread‑safe.
6. Classes atômicas avançadas
No pacote java.util.concurrent.atomic há outras classes úteis:
- AtomicLong, AtomicBoolean — para long e boolean.
- AtomicIntegerArray, AtomicReferenceArray — operações atômicas sobre arrays.
- LongAdder, LongAccumulator — para contadores de alta concorrência.
LongAdder e LongAccumulator
Se você tem muitos threads e um AtomicInteger comum se torna um “gargalo” (todas as threads competem por uma única variável), use LongAdder. Ele divide o contador em várias células internas e as soma quando o valor é solicitado, o que dá ganho em alta concorrência.
import java.util.concurrent.atomic.LongAdder;
public class FastCounter {
private final LongAdder adder = new LongAdder();
public void increment() {
adder.increment();
}
public long getCount() {
return adder.sum();
}
}
7. Erros típicos ao trabalhar com variáveis atômicas
Erro nº 1: esperar atomicidade de operações complexas.
Se for preciso realizar várias ações sobre um valor, as classes atômicas não salvam — entre os passos outra thread pode alterar os dados. Para operações compostas use compareAndSet ou sincronização.
Erro nº 2: ignorar a thread‑safety de objetos aninhados.
Se um AtomicReference contém um objeto comum, seus métodos e campos não se tornam thread‑safe. Atômica é apenas a troca da referência.
Erro nº 3: usar classes atômicas sem necessidade.
Em código single‑thread, tipos atômicos são redundantes e um pouco mais lentos que variáveis comuns devido a verificações adicionais.
Erro nº 4: otimização prematura.
Às vezes é mais simples e confiável usar synchronized, especialmente quando a lógica é complexa e envolve várias variáveis ao mesmo tempo. Nem sempre vale a pena construir soluções lock‑free.
Erro nº 5: esquecer o problema ABA.
Caso raro, mas importante: o valor muda de A para B e volta para A — compareAndSet “pensa” que nada mudou. Para tais cenários, use classes especiais como AtomicStampedReference (ou AtomicMarkableReference).
GO TO FULL VERSION