Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

Ordens de memória das operações atómicas

As constantes do tipo std::memory_order controlam a sincronização e a ordenação das operações atómicas. Aprende as diferenças entre relaxed, release, acquire, acq_rel e seq_cst e como uma flag atómica pode publicar dados normais em segurança.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

#include <atomic>
a.load(std::memory_order_acquire);
a.store(value, std::memory_order_release);
a.fetch_add(1, std::memory_order_relaxed);
a.exchange(value, std::memory_order_acq_rel);
a.load(std::memory_order_seq_cst);

As constantes de <atomic> do tipo std::memory_order selecionam regras de ordenação; não tornam atómicas as variáveis normais. Nomes como std::memory_order_relaxed correspondem a valores como std::memory_order::relaxed. Estas regras aplicam-se a C++23; eel.is disponibiliza um rascunho em evolução, não uma publicação C++23 imutável.

std::memory_order_relaxed mantém a atomicidade, mas por si só não sincroniza o acesso a outros dados entre threads. std::memory_order_release pode publicar escritas anteriores. std::memory_order_acquire sincroniza com uma operação release no mesmo objeto atómico quando lê o valor dessa operação ou um valor da respetiva sequência release. Não basta utilizar apenas os dois nomes.

std::memory_order_acq_rel combina acquire e release numa operação de leitura-modificação-escrita, como exchange. std::memory_order_seq_cst fornece as propriedades acquire/release aplicáveis e uma única ordem total das operações seq_cst. Não elimina corridas de dados nem inclui automaticamente nessa ordem as operações mais fracas.

Para load, entre estas cinco constantes, são válidas relaxed, acquire e seq_cst; para store, são válidas relaxed, release e seq_cst. acq_rel não é válido para um load ou store simples. Estas operações usam seq_cst por omissão. Enfraquecer uma ordem exige justificar a correção, não apenas medir a velocidade.

No exemplo, a leitura acquire de true sincroniza com a escrita release, pelo que payload = 42 acontece antes da sua leitura segundo a relação happens-before. Substituir ambas as ordens por relaxed eliminaria essa garantia e causaria uma corrida de dados em payload. O ciclo espera ativamente; o resultado ao terminar é determinado, mas o tempo de espera não tem um limite fixo.

Exemplos

#include <atomic>
#include <iostream>
#include <thread>

int main() {
    int payload = 0;
    std::atomic<bool> ready{false};

    std::thread producer([&] {
        payload = 42;
        ready.store(true, std::memory_order_release);
    });

    while (!ready.load(std::memory_order_acquire)) {
        std::this_thread::yield();
    }
    std::cout << payload << '\n';
    producer.join();
}

Resultado

42

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes