CodeGym /Cursos /JAVA 25 SELF /AtomicInteger, AtomicReference: operações atômicas

AtomicInteger, AtomicReference: operações atômicas

JAVA 25 SELF
Nível 53, Lição 3
Disponível

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:

  1. Ler o valor da variável (por exemplo, 5).
  2. Incrementar esse valor em 1.
  3. 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
get()
Obter o valor atual
set(int value)
Definir o valor
incrementAndGet()
Incrementar em 1 e retornar o novo valor
getAndIncrement()
Retornar o valor atual e incrementar em 1
addAndGet(int delta)
Incrementar em delta e retornar o novo valor
compareAndSet(expect, update)
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).

1
Tarefa
JAVA 25 SELF, nível 53, lição 3
Bloqueado
Contagem de visitantes em um megaevento: contador thread-safe 🏟️
Contagem de visitantes em um megaevento: contador thread-safe 🏟️
1
Tarefa
JAVA 25 SELF, nível 53, lição 3
Bloqueado
Atualizando o líder atual da guilda: Atualização segura de objeto com AtomicReference 👑
Atualizando o líder atual da guilda: Atualização segura de objeto com AtomicReference 👑
Comentários
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION