CKTIS / C++
std::atomic: accesso atomico a un valore condiviso
std::atomic offre load, store e operazioni read-modify-write indivisibili su un oggetto con ordine di memoria configurabile.
Versione: C++23
Sintassi
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> di <atomic> offre le operazioni comuni load, store, exchange e compare-exchange su un valore; l’ordine predefinito è std::memory_order_seq_cst. fetch_add non appartiene a ogni atomic<T>: è fornito solo dalle specializzazioni applicabili, incluse quelle numeriche e per puntatori. Per il template primario, T deve essere banalmente copiabile, costruibile e assegnabile per copia e spostamento, e privo di qualificazione cv. std::atomic::load esegue una lettura atomica e non ammette gli ordini release o acq_rel; std::atomic::store esegue una scrittura atomica e non ammette consume, acquire o acq_rel. In una specializzazione applicabile, std::atomic::fetch_add è un’unica operazione read-modify-write e restituisce il valore immediatamente precedente all’addizione; std::atomic::is_lock_free indica se le operazioni di quell’oggetto sono lock-free.
L’atomicità di una variabile non rende atomico un intero protocollo. Con ordini più deboli bisogna dimostrare la sincronizzazione; un mix errato di relaxed, acquire e release può essere logicamente sbagliato anche senza data race.
Un atomic non è necessariamente lock-free; controlla is_lock_free(). Gli oggetti atomici non si copiano come valori normali. compare_exchange_weak può fallire spuriosamente, quindi si usa di solito in un ciclo e aggiorna il valore atteso in caso di fallimento.
Esempi
#include <atomic>
#include <iostream>
int main() {
std::atomic<int> value{3};
value.fetch_add(4);
std::cout << value.load() << '\n';
}
Risultato
7
std::atomic → 7