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

O mecanismo CAS (Compare-And-Swap) é uma operação atómica que realiza três ações:

1. Ler o valor atual de uma célula de memória.
2. Comparar o valor lido com o valor esperado (old value).
3. Se os valores coincidirem, escrever um novo valor (new value) na célula.

Todas estas ações são realizadas como uma operação indivisível ao nível de hardware, o que previne condições de corrida em ambientes multithread sem usar bloqueios explícitos.

O CAS é utilizado em classes do pacote java.util.concurrent.atomic, como AtomicInteger, AtomicLong, AtomicReference.

Exemplo de pseudocódigo para a operação compareAndSet(expectedValue, newValue):

// Baseado em pseudocódigo para ilustração
boolean compareAndSet(int expectedValue, int newValue) {
    // Obter o valor atual da memória
    int currentValue = memory[address]; // Leitura atómica

    // Comparar o valor atual com o esperado
    if (currentValue == expectedValue) {
        // Se coincidirem, escrever o novo valor
        memory[address] = newValue; // Escrita atómica se a comparação for verdadeira
        return true; // Operação bem-sucedida
    } else {
        // Se não coincidirem, não fazer nada
        return false; // Operação mal-sucedida
    }
}

Vantagens do CAS:

• Não bloqueante: Os threads que tentam realizar CAS não bloqueiam diretamente outros threads (ao contrário dos bloqueios). Em caso de falha, o thread pode simplesmente tentar novamente.
• Alto desempenho: Em muitos processadores modernos, o CAS tem suporte de hardware, tornando-o uma operação muito rápida.
• Evitar deadlocks: Como os threads não mantêm bloqueios, o risco de deadlocks é eliminado.

Desvantagens do CAS:

• Problema ABA: Se entre a leitura e a tentativa de escrita outro valor foi alterado para B e depois voltou para A, o CAS pensará que não houve alteração, embora tenha ocorrido. Para resolver este problema, usam-se AtomicStampedReference ou AtomicMarkableReference, que adicionam uma etiqueta ou marca de alteração ao valor.
• Ciclos de espera (Spinning): Se a operação CAS for executada em ciclo até ter sucesso, pode levar a carga de CPU em situações de alta concorrência, pois os threads tentam repetidamente executar a operação.

O CAS é um bloco de construção fundamental para muitos algoritmos sem bloqueio no Java Concurrent Framework.