Namespaces
Variants

std:: atomic <std::shared_ptr>

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::shared_ptr
Member functions
Modifiers
Observers
(C++17)
( until C++20* )
(C++26)
(C++26)
Non-member functions
(C++20)
(C++20)
(C++17)
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20) (C++20)
functions ( until C++26* )
Helper classes
atomic <std::shared_ptr>
(C++20)
Deduction guides (C++17)
Definido en el encabezado <memory>
template < class T >
struct std:: atomic < std:: shared_ptr < T >> ;
(desde C++20)

La especialización parcial de plantilla de std::atomic para std:: shared_ptr < T > permite a los usuarios manipular objetos shared_ptr de forma atómica.

Si múltiples hilos de ejecución acceden al mismo objeto std::shared_ptr sin sincronización y alguno de esos accesos utiliza una función miembro no constante de shared_ptr entonces ocurrirá una condición de carrera (data race) a menos que todo dicho acceso se realice a través de una instancia de std:: atomic < std:: shared_ptr > (o, en desuso desde C++20, a través de las funciones independientes para acceso atómico a std::shared_ptr ).

Los incrementos asociados de use_count están garantizados como parte de la operación atómica. Los decrementos asociados de use_count se secuencian después de la operación atómica, pero no se requieren como parte de ella, excepto para el cambio de use_count al sobrescribir expected en un CAS fallido. Cualquier eliminación y desasignación asociadas se secuencian después del paso de actualización atómica y no forman parte de la operación atómica.

Tenga en cuenta que el bloque de control de un shared_ptr es seguro para hilos: diferentes objetos std::shared_ptr no atómicos pueden ser accedidos mediante operaciones mutables, como operator = o reset , simultáneamente por múltiples hilos, incluso cuando estas instancias son copias y comparten internamente el mismo bloque de control.

El tipo T puede ser un tipo incompleto.

Contenidos

Tipos de miembros

Tipo de miembro Definición
value_type std:: shared_ptr < T >

Funciones miembro

Todas las funciones no especializadas de std::atomic también están proporcionadas por esta especialización, y no hay funciones miembro adicionales.

atomic<shared_ptr<T>>:: atomic

constexpr atomic ( ) noexcept = default ;
(1)
constexpr atomic ( std:: nullptr_t ) noexcept : atomic ( ) { }
(2)
atomic ( std:: shared_ptr < T > desired ) noexcept ;
(3)
atomic ( const atomic & ) = delete ;
(4)
1,2) Inicializa el shared_ptr < T > subyacente al valor nulo.
3) Inicializa el shared_ptr < T > subyacente a una copia de desired . Como con cualquier tipo std::atomic , la inicialización no es una operación atómica.
4) Los tipos atómicos no son copiables/movibles.

atomic<shared_ptr<T>>:: operator=

void operator = ( const atomic & ) = delete ;
(1)
void operator = ( std:: shared_ptr < T > desired ) noexcept ;
(2)
void operator = ( std:: nullptr_t ) noexcept ;
(3)
1) Los tipos atómicos no son asignables por copia/movimiento.
2) Asignación de valor, equivalente a store ( desired ) .
3) Restablece el puntero compartido atómico al valor de puntero nulo. Equivalente a store ( nullptr ) ; .

atomic<shared_ptr<T>>:: is_lock_free

bool is_lock_free ( ) const noexcept ;

Devuelve true si las operaciones atómicas en todos los objetos de este tipo son libres de bloqueo, false en caso contrario.

atomic<shared_ptr<T>>:: store

void store ( std:: shared_ptr < T > desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;

Reemplaza atómicamente el valor de * this con el valor de desired como si fuera mediante p. swap ( desired ) donde p es el std:: shared_ptr < T > subyacente. La memoria se ordena de acuerdo con order . El comportamiento es indefinido si order es std::memory_order_consume , std::memory_order_acquire , o std::memory_order_acq_rel .

atomic<shared_ptr<T>>:: load

Devuelve atómicamente una copia del puntero compartido subyacente. La memoria se ordena de acuerdo con order . El comportamiento es indefinido si order es std::memory_order_release o std::memory_order_acq_rel .

atomic<shared_ptr<T>>:: operator std::shared_ptr<T>

operator std:: shared_ptr < T > ( ) const noexcept ;

Equivalente a return load ( ) ; .

atomic<shared_ptr<T>>:: exchange

Reemplaza atómicamente el std:: shared_ptr < T > subyacente con desired como si se hiciera mediante p. swap ( desired ) donde p es el std:: shared_ptr < T > subyacente y devuelve una copia del valor que p tenía inmediatamente antes del intercambio. La memoria se ordena según order . Esta es una operación atómica de lectura-modificación-escritura.

atomic<shared_ptr<T>>:: compare_exchange_weak, compare_exchange_strong

bool compare_exchange_strong ( std:: shared_ptr < T > & expected, std:: shared_ptr < T > desired,
std:: memory_order success, std:: memory_order failure ) noexcept ;
(1)
bool compare_exchange_weak ( std:: shared_ptr < T > & expected, std:: shared_ptr < T > desired,
std:: memory_order success, std:: memory_order failure ) noexcept ;
(2)
bool compare_exchange_strong ( std:: shared_ptr < T > & expected, std:: shared_ptr < T > desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;
(3)
bool compare_exchange_weak ( std:: shared_ptr < T > & expected, std:: shared_ptr < T > desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;
(4)
1) Si el std:: shared_ptr < T > subyacente almacena el mismo T * que expected y comparte la propiedad con él, o si tanto el subyacente como expected están vacíos, asigna desde desired al std:: shared_ptr < T > subyacente, retorna true y ordena la memoria de acuerdo con success ; de lo contrario, asigna desde el std:: shared_ptr < T > subyacente a expected , retorna false y ordena la memoria de acuerdo con failure . El comportamiento es indefinido si failure es std::memory_order_release o std::memory_order_acq_rel . En caso de éxito, la operación es una operación atómica de lectura-modificación-escritura en * this y expected no se accede después de la actualización atómica. En caso de fallo, la operación es una operación atómica de carga en * this y expected se actualiza con el valor existente leído del objeto atómico. Esta actualización del use_count de expected es parte de esta operación atómica, aunque la escritura en sí misma (y cualquier desalocación/destrucción posterior) no está obligada a serlo.
2) Igual que (1) , pero también puede fallar espuriamente.
3) Equivalente a: return compare_exchange_strong ( expected, desired, order, fail_order ) ; , donde fail_order es igual que order excepto que std::memory_order_acq_rel se reemplaza por std::memory_order_acquire y std::memory_order_release se reemplaza por std::memory_order_relaxed .
4) Equivalente a: return compare_exchange_weak ( expected, desired, order, fail_order ) ; , donde fail_order es igual que order excepto que std::memory_order_acq_rel se reemplaza por std::memory_order_acquire y std::memory_order_release se reemplaza por std::memory_order_relaxed .

atomic<shared_ptr<T>>:: wait

void wait ( std:: shared_ptr < T > old,
std:: memory_order order = std:: memory_order_seq_cst ) const noexcept ;

Realiza una operación de espera atómica.

Compara load ( order ) con old y si son equivalentes, se bloquea hasta que * this sea notificado por notify_one() o notify_all() . Esto se repite hasta que load ( order ) cambie. Esta función garantiza que solo retornará si el valor ha cambiado, incluso si la implementación subyacente se desbloquea espuriamente.

La memoria se ordena de acuerdo con order . El comportamiento es indefinido si order es std::memory_order_release o std::memory_order_acq_rel .

Notas: dos shared_ptr son equivalentes si almacenan el mismo puntero y comparten la propiedad o ambos están vacíos.

atomic<shared_ptr<T>>:: notify_one

void notify_one ( ) noexcept ;

Realiza una operación de notificación atómica.

Si hay un hilo bloqueado en operaciones de espera atómica (es decir, wait() ) en * this , entonces desbloquea al menos uno de dichos hilos; de lo contrario no hace nada.

atomic<shared_ptr<T>>:: notify_all

void notify_all ( ) noexcept ;

Realiza una operación de notificación atómica.

Desbloquea todos los hilos bloqueados en operaciones de espera atómica (es decir, wait() ) en * this , si los hay; de lo contrario no hace nada.

Constantes de miembro

La única constante miembro estándar std::atomic is_always_lock_free también es proporcionada por esta especialización.

atomic<shared_ptr<T>>:: is_always_lock_free

static constexpr bool is_always_lock_free = /*implementation-defined*/ ;

Notas

Macro de prueba de características Valor Std Característica
__cpp_lib_atomic_shared_ptr 201711L (C++20) std::atomic<std::shared_ptr>

Ejemplo

Esta sección está incompleta
Razón: sin ejemplo

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 3661 C++20 atomic<shared_ptr<T>> no era inicializable-constantemente desde nullptr hecho inicializable-constantemente
LWG 3893 C++20 LWG3661 hizo que atomic<shared_ptr<T>> no fuera asignable desde nullptr_t asignabilidad restaurada

Véase también

(C++11)
Plantilla de clase atomic y especializaciones para bool, tipos integrales, tipos de punto flotante, (desde C++20) y tipos puntero
(plantilla de clase)