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 voidstd::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.