O que é o mecanismo CAS (Compare-And-Swap)?

O mecanismo Compare-And-Swap (CAS) é uma operação atómica de máquina usada para implementar sincronização sem bloqueio.

Princípio de funcionamento:

1. Lê o valor atual da célula de memória (expectedValue).
2. Tenta escrever um novo valor (newValue) nessa célula apenas se o valor atual corresponder a expectedValue.
3. Retorna um valor booleano: true se a escrita for bem-sucedida (ou seja, houve correspondência), false caso contrário.

Em Java, CAS é implementado em classes do pacote java.util.concurrent.atomic, por exemplo, AtomicInteger, AtomicLong, AtomicReference.

Exemplo de uso de AtomicInteger:

// java
import java.util.concurrent.atomic.AtomicInteger;

public class CasExample {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        while (true) {
            int expectedValue = count.get(); // Lê o valor atual
            int newValue = expectedValue + 1;
            if (count.compareAndSet(expectedValue, newValue)) {
                // Se o valor atual não mudou desde a leitura,
                // realiza a escrita e sai do ciclo
                break;
            }
            // Se o valor mudou, tenta novamente
        }
    }
}

Vantagens:

• Não bloqueante: os threads não bloqueiam uns aos outros, reduzindo os custos de troca de contexto, especialmente em baixa concorrência.
• Evita problemas de deadlock.

Desvantagens:

• Problema ABA: se o valor da célula muda de A para B e depois volta a A, CAS pensará que não houve mudanças. Para resolver esse problema, usam-se classes como AtomicStampedReference ou AtomicMarkableReference.
• Pode ocorrer um grande número de tentativas falhadas (spin loops) em alta concorrência.