C++ Academy · Aula

std::atomic e ordens de memória

Use std::atomic com a ordenação de memória adequada para garantir correção e velocidade

std::atomic e ordens de memória é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 1 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.

Além dos mutexes

Os bloqueios serializam o acesso — são simples e corretos, mas limitam a vazão. std::atomic oferece blocos de construção sem bloqueio para código concorrente de alta vazão.

Noções básicas de std::atomic

Um std::atomic<T> encapsula um valor e oferece suporte a operações atômicas de leitura-modificação-escrita.

#include <atomic>
std::atomic<int> counter{0};
counter.fetch_add(1);    // atomic increment
int v = counter.load();
counter.store(0);

Operadores de conveniência

Para tipos aritméticos, os operadores usuais são atômicos.

std::atomic<int> n{0};
++n;          // atomic increment
n += 5;        // atomic add
int v = n;     // atomic load

Por que as operações atômicas são difíceis

A CPU pode reordenar operações de memória entre núcleos. A ordem de memória especifica quais reordenações são permitidas.

Ordens de memória

Cinco ordens comuns:

memory_order_relaxed — atômica, mas sem ordenação
memory_order_acquire — combina com release; nenhuma reordenação depois
memory_order_release — combina com acquire; nenhuma reordenação antes
memory_order_acq_rel — ambas
memory_order_seq_cst — consistente sequencialmente (padrão)

Consistência sequencial: padrão seguro

O seq_cst padrão se comporta de forma intuitiva — todas as operações atômicas parecem ser executadas em uma única ordem global. É mais lento que as ordens relaxadas, mas é mais fácil raciocinar sobre ele.

Emparelhamento acquire-release

Use release no produtor e acquire no consumidor. Depois de acquire, todas as escritas ocorridas antes do release correspondente ficam visíveis.

std::atomic<bool> ready{false};
int data = 0;

// producer
data = 42;
ready.store(true, std::memory_order_release);

// consumer
while (!ready.load(std::memory_order_acquire));
std::cout << data;    // sees 42

Ordem relaxada

As operações atômicas relaxadas garantem atomicidade (sem leituras fragmentadas), mas permitem qualquer reordenação. Use-as para contadores simples quando a ordenação não importar.

Comparar e trocar

A base da maioria dos algoritmos sem bloqueio. compare_exchange_strong(expected, desired) atualiza atomicamente somente se o valor atual for igual a expected.

std::atomic<int> a{10};
int expected = 10;
bool ok = a.compare_exchange_strong(expected, 20);
// if true, a is now 20; otherwise expected holds the actual current value

CAS fraco versus forte

compare_exchange_weak pode falhar espuriamente mesmo quando os valores coincidem. Use-o dentro de laços (é mais barato em algumas plataformas); use o forte fora dos laços.

Sem bloqueio versus sem espera

Duas garantias de progresso:

Sem bloqueio — pelo menos uma linha de execução progride a qualquer momento
Sem espera — todas as linhas de execução progridem em tempo limitado

Quando usar operações atômicas

As operações atômicas nem sempre são mais rápidas que os mutexes. Use-as quando puder manter o caminho crítico simples — contadores, sinalizadores, estado simples. Para estados compartilhados complexos, os mutexes geralmente são mais seguros e claros.

Verificação rápida

Qual ordem de memória oferece as garantias mais fortes, mas também é a mais lenta?

Recapitulação

std::atomic oferece primitivas sem bloqueio com ordenação de memória explícita. Use memory_order_seq_cst por padrão; use pares de acquire/release em padrões produtor-consumidor; use relaxed somente para operações atômicas sem ordenação, como contadores.

Perguntas Frequentes

A aula “std::atomic e ordens de memória” é grátis?

Sim — o texto completo de “std::atomic e ordens de memória” é 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 “std::atomic e ordens de memória”?

Use std::atomic com a ordenação de memória adequada para garantir correção e velocidade 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 1 de 4.

Quanto tempo leva a aula “std::atomic e ordens de memória”?

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

← Voltar para C++ Academy