Namespaces
Variants

std:: atomic_is_lock_free, ATOMIC_xxx_LOCK_FREE

From cppreference.net
C++
Concurrency support library
Threads
(C++11)
(C++20)
(C++17) (C++17)
this_thread namespace
(C++11)
(C++11)
Cooperative cancellation
Mutual exclusion
Generic lock management
Condition variables
(C++11)
(C++11)
(C++11)
(C++11)
Semaphores
(C++20) (C++20)
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Safe reclamation
Hazard pointers
(C++26)
(C++26)
(C++26)
Atomic types
(C++11)
(C++20)
(C++11)
Initialization of atomic types
(C++11) (deprecated in C++20)
(C++11) (deprecated in C++20)
(C++11)
Memory ordering
(C++11)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
Free functions for atomic operations
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11) (C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++26) (C++26)
(C++26) (C++26)
atomic_is_lock_free
(C++11)
(C++20) (C++20)
(C++20)
(C++20)
Free functions for atomic flags
(C++11) (C++11)
(C++11) (C++11)
(C++20) (C++20)
(C++20) (C++20)
(C++20)
(C++20)
Défini dans l'en-tête <atomic>
template < class T >
bool atomic_is_lock_free ( const volatile std:: atomic < T > * obj ) noexcept ;
(1) (depuis C++11)
template < class T >
bool atomic_is_lock_free ( const std:: atomic < T > * obj ) noexcept ;
(2) (depuis C++11)
#define ATOMIC_BOOL_LOCK_FREE     /* non spécifié */

#define ATOMIC_CHAR_LOCK_FREE     /* non spécifié */
#define ATOMIC_CHAR16_T_LOCK_FREE /* non spécifié */
#define ATOMIC_CHAR32_T_LOCK_FREE /* non spécifié */
#define ATOMIC_WCHAR_T_LOCK_FREE  /* non spécifié */
#define ATOMIC_SHORT_LOCK_FREE    /* non spécifié */
#define ATOMIC_INT_LOCK_FREE      /* non spécifié */
#define ATOMIC_LONG_LOCK_FREE     /* non spécifié */
#define ATOMIC_LLONG_LOCK_FREE    /* non spécifié */

#define ATOMIC_POINTER_LOCK_FREE  /* non spécifié */
(3) (depuis C++11)
#define ATOMIC_CHAR8_T_LOCK_FREE  /* non spécifié */
(4) (depuis C++20)
1,2) Détermine si l'objet atomique pointé par obj est implémenté sans verrou, comme s'il était appelé via obj - > is_lock_free ( ) . Dans toute exécution de programme donnée, le résultat de la requête sans verrou est le même pour tous les objets atomiques du même type.
3,4) Se développe en une expression constante entière de valeur
  • ​ 0 ​ pour les types atomiques intégrés qui ne sont jamais sans verrouillage,
  • 1 pour les types atomiques intégrés qui sont parfois sans verrouillage,
  • 2 pour les types atomiques intégrés qui sont toujours sans verrouillage.

Table des matières

Paramètres

obj - pointeur vers l'objet atomique à examiner

Valeur de retour

true si * obj est un atomique sans verrou, false sinon.

Notes

Tous les types atomiques, à l'exception de std::atomic_flag , peuvent être implémentés en utilisant des mutex ou d'autres opérations de verrouillage, plutôt qu'en utilisant les instructions atomiques sans verrou du CPU. Il est également permis que les types atomiques soient parfois sans verrou : par exemple, si seulement certaines sous-architectures supportent l'accès atomique sans verrou pour un type donné (comme l'instruction CMPXCHG16B sur x86-64), le fait que les atomiques soient sans verrou peut ne pas être connu avant l'exécution.

La norme C++ recommande (mais n'exige pas) que les opérations atomiques sans verrouillage soient également sans adresse, c'est-à-dire adaptées à la communication entre processus utilisant la mémoire partagée.

Exemple

Exécuter ce code 
#include <atomic>
#include <iostream>
#include <utility>
struct A { int a[4]; };
struct B { int x, y; };
int main()
{
    std::atomic<A> a;
    std::atomic<B> b;
    std::cout << std::boolalpha
              << "std::atomic<A> is lock free? "
              << std::atomic_is_lock_free(&a) << '\n'
              << "std::atomic<B> is lock free? "
              << std::atomic_is_lock_free(&b) << '\n';
}

Sortie possible : 

std::atomic<A> is lock free? false
std::atomic<B> is lock free? true

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.

DR Applicable à Comportement publié Comportement corrigé
LWG 3249 C++11 atomic_is_lock_free était spécifié via des pointeurs, ce qui
était ambigu et pouvait accepter des valeurs de pointeur invalides 		spécifié via
des objets atomiques

Voir aussi

vérifie si l'objet atomique est sans verrou
(fonction membre publique de std::atomic<T> )
(C++11)
le type atomique booléen sans verrou
(classe)
[static] (C++17)
indique que le type est toujours sans verrou
(constante membre statique publique de std::atomic<T> )
(obsolète en C++20) (supprimé en C++26)
spécialise les opérations atomiques pour std::shared_ptr
(modèle de fonction)
Documentation C pour atomic_is_lock_free
Documentation C pour ATOMIC_*_LOCK_FREE