Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::atomic : accès atomique à une valeur partagée

std::atomic fournit des lectures, écritures et opérations read-modify-write indivisibles sur un objet avec un ordre mémoire configurable.

Version : C++23

Syntaxe

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> fournit les opérations communes load, store, exchange et compare-exchange sur une valeur ; l’ordre par défaut est std::memory_order_seq_cst. fetch_add n’appartient pas à toute interface atomic<T> : seules les spécialisations appropriées, notamment numériques et pointeurs, le fournissent. Pour le patron principal, T doit être trivialement copiable, constructible et affectable par copie et déplacement, et sans qualification cv. std::atomic::load effectue une lecture atomique et interdit les ordres release et acq_rel ; std::atomic::store effectue une écriture atomique et interdit consume, acquire et acq_rel. Sur une spécialisation appropriée, std::atomic::fetch_add est une unique opération read-modify-write et renvoie la valeur précédant immédiatement l’addition ; std::atomic::is_lock_free indique si les opérations de cet objet sont sans verrou.

L’atomicité d’une variable ne rend pas tout un protocole atomique. Avec des ordres plus faibles, la relation de synchronisation doit être démontrée ; un mauvais mélange de relaxed, acquire et release peut rester logiquement faux sans data race.

Un atomic n’est pas forcément lock-free ; consulte is_lock_free(). Les objets atomiques ne se copient pas comme des valeurs ordinaires. compare_exchange_weak peut échouer sans conflit, donc on l’utilise souvent en boucle et il met à jour la valeur attendue lors d’un échec.

Exemples

#include <atomic>
#include <iostream>

int main() {
    std::atomic<int> value{3};
    value.fetch_add(4);
    std::cout << value.load() << '\n';
}

Résultat

7

std::atomic → 7

Sources