CKTIS / C++
std::atomic_thread_fence — sincronización mediante barreras de memoria
std::atomic_thread_fence establece restricciones de orden de memoria sin leer ni escribir un objeto concreto. La sincronización entre hilos requiere operaciones atómicas conectadas adecuadamente; las barreras por sí solas no bastan.
Versión: C++23; repository compiler flag, production runtime not attested
Sintaxis
#include <atomic>
std::atomic_thread_fence(order); // order: std::memory_order; returns voidstd::atomic_thread_fence(order) de <atomic> devuelve void y no lanza excepciones. Una barrera no opera sobre un objeto atómico concreto. No es un bloqueo ni una orden incondicional para «vaciar la caché».
En C++23, std::memory_order_relaxed no tiene efecto. Tanto std::memory_order_consume como std::memory_order_acquire crean una barrera acquire. std::memory_order_release crea una barrera release y std::memory_order_acq_rel crea una barrera con ambas propiedades. std::memory_order_seq_cst crea una barrera acquire y release secuencialmente consistente.
En el ejemplo, la escritura en payload precede a la barrera release, seguida de la escritura atómica en ready. La lectura de ready que observa true de esa escritura precede a la barrera acquire. Esta cadena sincroniza las barreras y hace que la escritura en payload ocurra antes que su lectura: el resultado es 42, sin una carrera de datos. Añadir barreras sin esta conexión atómica no protege los datos ordinarios.
Una barrera release también puede conectarse con una lectura acquire, o una escritura release con una barrera acquire, si se da la relación reads-from requerida. std::atomic_signal_fence restringe el orden únicamente entre un hilo y un controlador de señales ejecutado en ese mismo hilo. La fuente proporcionada es un borrador de norma en evolución, no el texto definitivo de C++23.
Ejemplos
#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
El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.