CKTIS / C++
std::atomic: acceso atómico a un valor compartido
std::atomic ofrece cargas, almacenes y operaciones read-modify-write indivisibles sobre un objeto con orden de memoria configurable.
Versión: C++23
Sintaxis
template<class T>
struct atomic; // T: non-cv, trivially copyable, copy/move constructible and assignable
// common selected operations
T load(std::memory_order order = std::memory_order_seq_cst) const noexcept;
void store(T desired, std::memory_order order = std::memory_order_seq_cst) noexcept;
bool is_lock_free() const noexcept;
T exchange(T desired, std::memory_order order = std::memory_order_seq_cst) noexcept;
// applicable numeric and pointer specializations additionally provide:
T fetch_add(/* difference type */ operand,
std::memory_order order = std::memory_order_seq_cst) noexcept;std::atomic<T>, de <atomic>, ofrece las operaciones comunes load, store, exchange y compare-exchange sobre un valor; el orden predeterminado es std::memory_order_seq_cst. fetch_add no forma parte de todo atomic<T>: solo lo ofrecen especializaciones aplicables, incluidas las numéricas y de punteros. Para la plantilla primaria, T debe ser trivialmente copiable, construible y asignable por copia y movimiento, y no tener calificación cv. std::atomic::load realiza una lectura atómica y no admite los órdenes release ni acq_rel; std::atomic::store realiza una escritura atómica y no admite consume, acquire ni acq_rel. En una especialización aplicable, std::atomic::fetch_add es una única operación read-modify-write y devuelve el valor inmediatamente anterior a la suma; std::atomic::is_lock_free indica si las operaciones de ese objeto están libres de bloqueo.
La atomicidad de una variable no vuelve atómico un protocolo completo. Con órdenes más débiles hay que demostrar la sincronización; una mezcla errónea de relaxed, acquire y release puede ser lógicamente incorrecta aun sin data race.
Un atomic no es necesariamente lock-free; consulta is_lock_free(). Los objetos atómicos no se copian como valores normales. compare_exchange_weak puede fallar espuriamente, por lo que suele ir en un bucle y actualiza el valor esperado cuando falla.
Ejemplos
#include <atomic>
#include <iostream>
int main() {
std::atomic<int> value{3};
value.fetch_add(4);
std::cout << value.load() << '\n';
}
Resultado
7
std::atomic → 7