std:: atomic

Chaque instanciation et spécialisation complète du modèle std::atomic définit un type atomique. Si un thread écrit dans un objet atomique pendant qu'un autre thread le lit, le comportement est bien défini (voir le modèle de mémoire pour plus de détails sur les courses de données).

De plus, les accès aux objets atomiques peuvent établir une synchronisation inter-threads et ordonner les accès mémoire non atomiques comme spécifié par std::memory_order .

std::atomic n'est ni copiable ni déplaçable.

Spécialisations

Modèle principal

Le modèle principal std::atomic peut être instancié avec tout type TriviallyCopyable T satisfaisant à la fois CopyConstructible et CopyAssignable . Le programme est mal formé si l'une des valeurs suivantes est false :

• std:: is_trivially_copyable < T > :: value
• std:: is_copy_constructible < T > :: value
• std:: is_move_constructible < T > :: value
• std:: is_copy_assignable < T > :: value
• std:: is_move_assignable < T > :: value
• std:: is_same < T, typename std:: remove_cv < T > :: type > :: value

struct Counters { int a; int b; }; // type défini par l'utilisateur trivialement copiable
std::atomic<Counters> cnt;         // spécialisation pour le type défini par l'utilisateur

std :: atomic < bool > utilise le modèle principal. Il est garanti d'être une structure de disposition standard et possède un destructeur trivial .

Spécialisations partielles

La bibliothèque standard fournit des spécialisations partielles du modèle std::atomic pour les types suivants avec des propriétés supplémentaires que le modèle principal ne possède pas :

Spécialisations pour les types entiers

Lorsqu'il est instancié avec l'un des types entiers suivants, std::atomic fournit des opérations atomiques supplémentaires appropriées aux types entiers telles que fetch_add , fetch_sub , fetch_and , fetch_or , fetch_xor :

• Les types de caractères char , char8_t (depuis C++20) , char16_t , char32_t , et wchar_t ;
• Les types entiers signés standards : signed char , short , int , long , et long long ;
• Les types entiers non signés standards : unsigned char , unsigned short , unsigned int , unsigned long , et unsigned long long ;
• Tout type entier supplémentaire requis par les typedefs dans l'en-tête <cstdint> .

De plus, la spécialisation résultante std::atomic< Integral > a une disposition standard , un constructeur par défaut trivial, (jusqu'à C++20) et un destructeur trivial. L'arithmétique des entiers signés est définie pour utiliser le complément à deux ; il n'y a pas de résultats indéfinis.

Types membres

1. ↑ difference_type n'est pas défini dans le modèle principal std::atomic ou dans les spécialisations partielles pour std::shared_ptr et std::weak_ptr .

Fonctions membres

Fonctions membres spécialisées

Alias de types

Des alias de type sont fournis pour bool et tous les types entiers listés ci-dessus, comme suit :

Notes

Il existe des équivalents de modèles de fonctions non membres pour toutes les fonctions membres de std::atomic . Ces fonctions non membres peuvent être en outre surchargées pour des types qui ne sont pas des spécialisations de std::atomic , mais sont capables de garantir l'atomicité. Le seul type de ce genre dans la bibliothèque standard est std:: shared_ptr < U > .

_Atomic est un mot-clé et est utilisé pour fournir les types atomiques en C.

Il est recommandé que les implémentations garantissent que la représentation de _Atomic(T) en C soit identique à celle de std::atomic<T> en C++ pour tout type T possible. Les mécanismes utilisés pour assurer l'atomicité et l'ordonnancement de la mémoire devraient être compatibles.

Sur GCC et Clang, certaines fonctionnalités décrites ici nécessitent une liaison avec -latomic .

Exemple

#include <atomic>
#include <iostream>
#include <thread>
#include <vector>
std::atomic_int acnt;
int cnt;
void f()
{
    for (auto n{10000}; n; --n)
    {
        ++acnt;
        ++cnt;
        // Note: for this example, relaxed memory order is sufficient,
        // e.g. acnt.fetch_add(1, std::memory_order_relaxed);
    }
}
int main()
{
    {
        std::vector<std::jthread> pool;
        for (int n = 0; n < 10; ++n)
            pool.emplace_back(f);
    }
    std::cout << "The atomic counter is " << acnt << '\n'
              << "The non-atomic counter is " << cnt << '\n';
}

The atomic counter is 100000
The non-atomic counter is 69696

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi