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

CKTIS / C++

std::memory_order — orden de las operaciones atómicas

std::memory_order de <atomic> especifica el orden y la sincronización de las operaciones atómicas. Distingue la atomicidad por sí sola de la publicación segura de datos entre hilos; debilitar el orden de forma incorrecta puede provocar una condición de carrera de datos.

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

Sintaxis

#include <atomic>
// Examples of explicit ordering:
flag.store(true, std::memory_order::release);
bool value = flag.load(std::memory_order::acquire);

std::memory_order es una enumeración de <atomic> que se pasa a las operaciones atómicas. La atomicidad se refiere al objeto concreto; el orden de memoria especifica garantías adicionales sobre otras lecturas y escrituras. relaxed conserva la atomicidad y el orden de modificación de ese objeto, pero por sí solo no sincroniza el acceso a otros datos.

release publica escrituras anteriores, y acquire permite observarlas de forma segura: una lectura acquire se sincroniza con una escritura release cuando lee el valor de esa escritura o lee de la secuencia release correspondiente. acq_rel combina ambas direcciones en una operación de lectura-modificación-escritura. seq_cst, el valor predeterminado de muchas operaciones atómicas, también participa en un único orden total de las operaciones seq_cst; no ordena automáticamente todas las acciones del programa.

En C++23, consume describe un orden más débil, basado en dependencias de datos, y no un orden acquire completo. Nota sobre la versión: el borrador evolutivo enlazado no es el texto definitivo de C++23; actualmente describe consume como un equivalente obsoleto de acquire. Para la publicación habitual de datos, usa release/acquire en vez de depender de las sutilezas de consume.

Para store, los órdenes permitidos son relaxed, release, seq_cst; para load en C++23: relaxed, consume, acquire, seq_cst. acq_rel no es válido para un load o store simple. Un orden no válido incumple los requisitos de la operación; volatile no sustituye a la sincronización.

En el ejemplo, wait con acquire solo retorna después de observar un valor distinto de false. Lee el true publicado mediante release, así que la escritura de payload ocurre antes que su lectura en la relación happens-before y la salida es 42. notify_one() por sí solo no publica datos. Sustituir ambos órdenes por relaxed eliminaría esta garantía y permitiría una condición de carrera de datos sobre payload.

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);
        ready.notify_one();
    });

    ready.wait(false, 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