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

CKTIS / C++

Órdenes de memoria de las operaciones atómicas

Las constantes de tipo std::memory_order controlan la sincronización y el orden de las operaciones atómicas. Aprende en qué se diferencian relaxed, release, acquire, acq_rel y seq_cst, y cómo una bandera atómica puede publicar datos normales de forma segura.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

#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);

Las constantes de <atomic> de tipo std::memory_order seleccionan reglas de orden; no convierten en atómicas las variables normales. Nombres como std::memory_order_relaxed corresponden a valores como std::memory_order::relaxed. Estas reglas se aplican a C++23; eel.is aloja un borrador en evolución, no una publicación inmutable de C++23.

std::memory_order_relaxed conserva la atomicidad, pero por sí mismo no sincroniza el acceso a otros datos entre hilos. std::memory_order_release puede publicar escrituras anteriores. std::memory_order_acquire se sincroniza con una operación release sobre el mismo objeto atómico cuando lee el valor de esa operación o un valor de su secuencia release. No basta con usar ambos nombres.

std::memory_order_acq_rel combina acquire y release en una operación de lectura-modificación-escritura, como exchange. std::memory_order_seq_cst proporciona las propiedades acquire/release aplicables y un único orden total de las operaciones seq_cst. No corrige las carreras de datos ni incorpora automáticamente las operaciones más débiles a ese orden.

Para load, las opciones válidas entre estas cinco constantes son relaxed, acquire y seq_cst; para store, son relaxed, release y seq_cst. acq_rel no es válido para un load o store simple. Estos métodos usan seq_cst de forma predeterminada. Debilitar un orden requiere justificar la corrección, no solo medir la velocidad.

En el ejemplo, la lectura acquire de true se sincroniza con la escritura release, por lo que payload = 42 ocurre antes de su lectura según la relación happens-before. Si se sustituyeran ambos órdenes por relaxed, se perdería esa garantía y habría una carrera de datos sobre payload. El bucle espera activamente; la salida al terminar está determinada, pero el tiempo de espera no tiene un límite fijo.

Ejemplos

#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

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