Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

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 void

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

Fuentes