CKTIS / C++
Carga atómica de `std::shared_ptr` con orden de memoria explícito
En C++23, esta sobrecarga obsoleta copia un `std::shared_ptr` de forma atómica y permite elegir el orden de memoria de la carga.
Versión: ISO C++23; implementation support may vary
Sintaxis
// ISO C++23 — declared in <memory>
namespace std {
template<class T>
shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order order);
}
// For std::shared_ptr<T> slot:
auto snapshot = std::atomic_load_explicit(&slot, std::memory_order_acquire);Esta sobrecarga de la función libre std::atomic_load_explicit se declara en <memory>. Pasa &slot, la dirección de un objeto std::shared_ptr<T> que siga vivo, no la dirección del objeto apuntado ni la de un std::atomic<T>. La función devuelve por valor una copia de tipo std::shared_ptr<T> y no lanza excepciones. Si el valor cargado participaba en la propiedad compartida, la copia mantiene esa participación. Pasar una dirección nula para slot provoca un comportamiento indefinido. En cambio, el puntero almacenado en slot puede ser nulo; comprueba el resultado antes de desreferenciarlo si existe esa posibilidad.
En C++23, los órdenes de carga válidos son std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire y std::memory_order_seq_cst. Usar std::memory_order_release o std::memory_order_acq_rel provoca un comportamiento indefinido. La forma abreviada std::atomic_load(&slot) usa std::memory_order_seq_cst.
Si una carga con semántica de adquisición lee el valor escrito en el mismo slot por std::atomic_store_explicit con std::memory_order_release, la escritura se sincroniza con la lectura. La inicialización anterior a la escritura queda así visible para el código que se ejecuta después de la lectura. Una barrera std::atomic_thread_fence(std::memory_order_release) antes de esa escritura es redundante para esta publicación. Una carga con std::memory_order_relaxed sigue siendo atómica, pero no ofrece por sí sola esta sincronización.
Si varios hilos acceden al mismo slot y al menos uno puede modificarlo, no mezcles esta API con copias ordinarias, asignaciones o llamadas a reset() sobre ese objeto, salvo que los accesos se sincronicen por separado. Por ejemplo, una asignación ordinaria o una llamada a reset() en un hilo puede provocar una carrera de datos con una carga atómica en otro hilo. La carga atómica no protege las modificaciones posteriores del objeto apuntado ni se garantiza que funcione sin bloqueos. La sobrecarga se introdujo en C++11, quedó obsoleta en C++20, se mantuvo en C++23 y se eliminó del estándar C++26. En código nuevo, usa std::atomic<std::shared_ptr<T>> con load(order) y store(value, order).
Ejemplos
#include <atomic>
#include <iostream>
#include <memory>
int main() {
std::shared_ptr<const int> slot;
std::atomic_store_explicit(&slot, std::make_shared<const int>(42),
std::memory_order_release);
const auto snapshot = std::atomic_load_explicit(&slot, std::memory_order_acquire);
std::atomic_store_explicit(&slot, std::shared_ptr<const int>{},
std::memory_order_relaxed);
std::cout << *snapshot << '\n';
}Resultado
42
El programa de un solo hilo imprime `42` porque `snapshot` conserva la propiedad compartida después de vaciar `slot`. Muestra la sintaxis y el tiempo de vida, no la sincronización entre hilos.
Lecciones relacionadas
- C++ · Lección 37 · Avanzado · Versión: 3
Fuentes
- C++23 final working draft (N4950) — shared_ptr atomic access [depr.util.smartptr.shared.atomic]
- WG21 P2869R0 — Remove Deprecated shared_ptr Atomic Access APIs From C++26
- C++ working draft — Annex D compatibility changes from ISO C++ 2023 [diff.cpp23.depr]
- C++ working draft — Order and consistency [atomics.order]
- C++ working draft — Fences [atomics.fences]
- C++ working draft — Partial specialization for shared_ptr [util.smartptr.atomic.shared]