Namespaces
Variants

std::atomic_ref<T>:: compare_exchange_weak, std::atomic_ref<T>:: compare_exchange_strong

From cppreference.net
Concurrency support library
Threads
(C++11)
(C++20)
this_thread namespace
(C++11)
(C++11)
Cooperative cancellation
Mutual exclusion
Generic lock management
Condition variables
(C++11)
Semaphores
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
Safe reclamation
Hazard pointers
Atomic types
(C++11)
(C++20)
Initialization of atomic types
(C++11) (deprecated in C++20)
(C++11) (deprecated in C++20)
Memory ordering
(C++11) (deprecated in C++26)
Free functions for atomic operations
Free functions for atomic flags
bool compare_exchange_weak

( value_type & expected, value_type desired,
std:: memory_order success,

std:: memory_order failure ) const noexcept ;
(1) (constexpr desde C++26)
bool compare_exchange_weak

( value_type & expected, value_type desired,
std:: memory_order order =

std:: memory_order_seq_cst ) const noexcept ;
(2) (constexpr desde C++26)
bool compare_exchange_strong

( value_type & expected, value_type desired,
std:: memory_order success,

std:: memory_order failure ) const noexcept ;
(3) (constexpr desde C++26)
bool compare_exchange_strong

( value_type & expected, value_type desired,
std:: memory_order order =

std:: memory_order_seq_cst ) const noexcept ;
(4) (constexpr desde C++26)

Compara atómicamente la representación del valor del objeto referenciado con la de expected , y si son bit a bit iguales, reemplaza la primera con desired (realiza una operación de lectura-modificación-escritura). De lo contrario, carga el valor real almacenado en el objeto referenciado en expected (realiza una operación de carga).

1,3) Los modelos de memoria para las operaciones de lectura-modificación-escritura y carga son success y failure respectivamente.
2,4) order se utiliza tanto para operaciones de lectura-modificación-escritura como de carga, excepto que std:: memory_order_acquire y std:: memory_order_relaxed se utilizan para la operación de carga si order es std:: memory_order_acq_rel o std:: memory_order_release respectivamente.

Estas sobrecargas participan en la resolución de sobrecarga solo si std:: is_const_v < T > es false .

Si failure no es std:: memory_order_relaxed , std:: memory_order_consume , std:: memory_order_acquire o std:: memory_order_seq_cst , el comportamiento es indefinido.

Contenidos

Parámetros

expected - referencia al valor que se espera encontrar en el objeto referenciado por el atomic_ref objeto
desired - el valor a almacenar en el objeto referenciado si coincide con el valor esperado
success - el orden de sincronización de memoria para la operación de lectura-modificación-escritura si la comparación tiene éxito
failure - el orden de sincronización de memoria para la operación de carga si la comparación falla
order - el orden de sincronización de memoria para ambas operaciones

Valor de retorno

true si el objeto referenciado fue modificado exitosamente, false en caso contrario.

Notas

La comparación y copia son a nivel de bits (similar a std::memcmp y std::memcpy ); no se utilizan constructor, operador de asignación ni operador de comparación.

Las formas débiles (1,2) de las funciones pueden fallar espuriamente, es decir, actuar como si * this ! = expected incluso si son iguales. Cuando un compare-and-exchange está en un bucle, la versión débil proporcionará mejor rendimiento en algunas plataformas.

Cuando una comparación e intercambio débil requeriría un bucle y una fuerte no, la fuerte es preferible a menos que la representación del objeto de value_type pueda incluir bits de trampa, u ofrezca múltiples representaciones de objeto para el mismo valor (por ejemplo, NaN de punto flotante). En esos casos, la comparación e intercambio débil normalmente funciona porque converge rápidamente en alguna representación de objeto estable.

Para una unión con bits que participan en las representaciones de valor de algunos miembros pero no de otros, la comparación e intercambio podría fallar siempre porque dichos bits de relleno tienen valores indeterminados cuando no participan en la representación de valor del miembro activo.

Los bits de relleno que nunca participan en la representación del valor de un objeto son ignorados.

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 3508
( P3323R1 )
C++20 compare_exchange_weak y compare_exchange_strong
carecían de sentido para const T
restringido para aceptar solo T no constante

Ejemplo