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

CKTIS / C++

Escritura atómica de std::shared_ptr con orden de memoria explícito

La sobrecarga antigua publica un std::shared_ptr mediante una escritura release y una lectura acquire. Sigue en C++23; para código nuevo, prefiere std::atomic<std::shared_ptr<T>>.

Versión: ISO C++23; implementation support may vary

Sintaxis

#include <atomic>
#include <memory>

namespace std {
    template<class T>
    void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> desired,
                               memory_order order);
}

std::atomic_store_explicit(shared_ptr) designa la sobrecarga de la función libre de <memory> que recibe la dirección de un std::shared_ptr<T> ordinario, no la de un std::atomic<T>. Sustituye *p de forma atómica por el parámetro desired pasado por valor, como si ejecutara p->swap(desired), y devuelve void. p debe apuntar a un objeto vivo, pero el shared_ptr que se guarda puede estar vacío. No se garantiza que la operación esté libre de bloqueos.

Durante el uso concurrente, no mezcles estas funciones con lecturas directas, asignaciones ni llamadas a reset() sobre la misma instancia compartida. std::atomic_load_explicit devuelve otro shared_ptr por valor. Las copias pueden compartir un bloque de control y mantener vivo el objeto gestionado, pero no evitan las carreras de datos sobre su contenido mutable.

Si una lectura con std::memory_order_acquire lee el valor escrito por una escritura con std::memory_order_release, la escritura se sincroniza con la lectura. La inicialización anterior a la escritura queda visible para el código posterior a la lectura. Un std::atomic_thread_fence(std::memory_order_release) justo antes de esa escritura es redundante en este patrón. std::memory_order_relaxed conserva la atomicidad, pero no proporciona por sí solo esa garantía de publicación. En C++23 la escritura antigua prohíbe explícitamente acquire y acq_rel, y la lectura antigua prohíbe release y acq_rel; incumplir estas precondiciones produce comportamiento indefinido.

Estas sobrecargas libres se introdujeron en C++11, quedaron obsoletas en C++20 y se eliminaron en C++26. Siguen formando parte de C++23; la compatibilidad puede variar según la implementación. Para código nuevo, usa std::atomic<std::shared_ptr<T>> y sus funciones miembro store y load.

Ejemplos

#include <atomic>
#include <iostream>
#include <memory>
#include <thread>

struct Config {
    int limit;
};

int main() {
    std::shared_ptr<const Config> published;
    std::thread publisher([&] {
        auto next = std::make_shared<const Config>(Config{42});
        std::atomic_store_explicit(&published, next, std::memory_order_release);
    });

    std::shared_ptr<const Config> snapshot;
    while (!(snapshot = std::atomic_load_explicit(
                 &published, std::memory_order_acquire))) {
        std::this_thread::yield();
    }

    std::cout << snapshot->limit << '\n';
    publisher.join();
}

Resultado

42

El hilo principal repite la lectura acquire hasta obtener una copia no vacía. Imprime `42` antes de `join()`; la configuración se publica mediante el par release/acquire, no mediante `join()`.

Lecciones relacionadas

  • C++ · Lección 37 · Avanzado · Versión: 3

Fuentes