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

CKTIS / C++

std::atomic_thread_fence — sincronização através de fences de memória

std::atomic_thread_fence estabelece restrições à ordem da memória sem ler nem escrever um objeto específico. A sincronização entre threads exige operações atómicas ligadas de forma adequada; os fences, por si só, não são suficientes.

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

Sintaxe

#include <atomic>
std::atomic_thread_fence(order); // order: std::memory_order; returns void

std::atomic_thread_fence(order) de <atomic> devolve void e não lança exceções. Um fence não opera sobre um objeto atómico específico. Não é um bloqueio nem uma ordem incondicional para «limpar a cache».

Em C++23, std::memory_order_relaxed não tem efeito. Tanto std::memory_order_consume como std::memory_order_acquire criam um fence acquire. std::memory_order_release cria um fence release e std::memory_order_acq_rel cria um fence com ambas as propriedades. std::memory_order_seq_cst cria um fence acquire e release sequencialmente consistente.

No exemplo, a escrita em payload precede o fence release, após o qual ocorre a escrita atómica em ready. A leitura de ready que observa true proveniente dessa escrita precede o fence acquire. Esta cadeia sincroniza os fences e faz com que a escrita em payload aconteça antes da sua leitura: o resultado é 42, sem uma data race. Acrescentar fences sem esta ligação atómica não protege os dados comuns.

Um fence release também pode ligar-se a uma leitura acquire, ou uma escrita release a um fence acquire, desde que exista a relação reads-from necessária. std::atomic_signal_fence restringe a ordem apenas entre uma thread e um gestor de sinais executado nessa mesma thread. A fonte fornecida é um projeto de norma em evolução, não o texto definitivo de C++23.

Exemplos

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

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

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

    while (!ready.load(std::memory_order_relaxed)) {
        std::this_thread::yield();
    }
    std::atomic_thread_fence(std::memory_order_acquire);
    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