Padrões de compare-and-swap: CAS
Implemente atualizações sem bloqueios com compare_exchange_weak e compare_exchange_strong
Padrões de compare-and-swap: CAS é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.
A primitiva CAS
Comparar e trocar lê, compara e escreve condicionalmente de forma atômica. É a base da maioria dos algoritmos sem bloqueio.
Comparação e troca no C++
Duas variantes em std::atomic:
compare_exchange_strong(expected, desired)— tem êxito quando o valor atual é igual ao esperadocompare_exchange_weak(expected, desired)— pode falhar espuriamente
Anatomia de um laço CAS
O laço CAS clássico: leia, calcule e tente escrever. Tente novamente se outra linha de execução vencer a disputa.
std::atomic<int> a{0};
int old = a.load();
int next;
do {
next = compute_new(old);
} while (!a.compare_exchange_weak(old, next));CAS para atualização atômica
Use CAS quando o novo valor depender do antigo. Um store simples perderia atualizações de linhas de execução concorrentes.
// Atomic max
int current = a.load();
while (newval > current && !a.compare_exchange_weak(current, newval));Pilha sem bloqueio: push
Uma operação push simples de uma pilha sem bloqueio usa CAS para instalar um novo nó no topo.
struct Node { int value; Node* next; };
std::atomic<Node*> head{nullptr};
void push(int v) {
Node* n = new Node{v, nullptr};
n->next = head.load();
while (!head.compare_exchange_weak(n->next, n));
}Falha espúria
compare_exchange_weak pode falhar mesmo quando os valores coincidem — em plataformas como ARM, nas quais a instrução subjacente pode falhar. Use-o dentro de laços; use strong quando tentar novamente for caro.
Padrão de atualização: redefinição
Para redefinir um valor para um estado conhecido somente se ele não tiver mudado.
int expected = 42;
if (a.compare_exchange_strong(expected, 0)) {
// a was 42 and is now 0
}Bloco de construção: contador atômico
Para um contador simples, fetch_add é mais simples e rápido que um laço CAS.
Bloco de construção: sinalizador atômico
Para um sinalizador booleano simples, std::atomic_flag é mais leve que std::atomic<bool> e oferece suporte a test_and_set.
Raciocinando sobre concorrência
O código sem bloqueio é famoso por ser difícil de analisar. Use testes rigorosos (TSan, entradas aleatórias), modelos formais quando disponíveis e prefira implementações existentes, exaustivamente testadas.
Quando escolher CAS
Use CAS quando:
- Várias linhas de execução atualizam o mesmo valor com frequência
- Os mutexes apresentam contenção como um gargalo
- A seção crítica é muito curta e simples
Quando não usar CAS
Evite CAS quando:
- A atualização precisar de mais de algumas operações
- A correção for mais importante que a vazão
- A equipe não tiver experiência em programação sem bloqueio
Verificação rápida
Por que normalmente usamos compare_exchange_weak dentro de um laço?
Recapitulação
Comparar e trocar atualiza atomicamente um valor somente se ele for igual ao valor esperado. Os laços CAS lidam com atualizações concorrentes sem bloqueios. Use compare_exchange_weak dentro de laços e strong para tentativas únicas.
Aprenda C++ com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 51
- Aulas
- 203
Perguntas Frequentes
A aula “Padrões de compare-and-swap: CAS” é grátis?
Sim — o texto completo de “Padrões de compare-and-swap: CAS” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.
O que vou aprender em “Padrões de compare-and-swap: CAS”?
Implemente atualizações sem bloqueios com compare_exchange_weak e compare_exchange_strong Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar C++ Academy?
Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Padrões de compare-and-swap: CAS”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de C++ Academy?
Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- std::atomic e ordens de memória
- Padrões de compare-and-swap: CAS
- Implementação de uma fila sem bloqueios
- Ponteiros de perigo e o problema ABA