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)
Definiert im Header <atomic>
template < class T >
bool atomic_is_lock_free ( const volatile std:: atomic < T > * obj ) noexcept ;
(1) (seit C++11)
template < class T >
bool atomic_is_lock_free ( const std:: atomic < T > * obj ) noexcept ;
(2) (seit C++11)
#define ATOMIC_BOOL_LOCK_FREE     /* unspecified */

#define ATOMIC_CHAR_LOCK_FREE     /* unspecified */
#define ATOMIC_CHAR16_T_LOCK_FREE /* unspecified */
#define ATOMIC_CHAR32_T_LOCK_FREE /* unspecified */
#define ATOMIC_WCHAR_T_LOCK_FREE  /* unspecified */
#define ATOMIC_SHORT_LOCK_FREE    /* unspecified */
#define ATOMIC_INT_LOCK_FREE      /* unspecified */
#define ATOMIC_LONG_LOCK_FREE     /* unspecified */
#define ATOMIC_LLONG_LOCK_FREE    /* unspecified */

#define ATOMIC_POINTER_LOCK_FREE  /* unspecified */
(3) (seit C++11)
#define ATOMIC_CHAR8_T_LOCK_FREE  /* unspecified */
(4) (seit C++20)
1,2) Bestimmt, ob das atomare Objekt, auf das obj zeigt, lock-free implementiert ist, als ob durch Aufruf von obj - > is_lock_free ( ) . In jeder gegebenen Programmausführung ist das Ergebnis der Lock-Free-Abfrage für alle atomaren Objekte desselben Typs gleich.
3,4) Erweitert sich zu einem ganzzahligen konstanten Ausdruck mit dem Wert
  • ​ 0 ​ für die eingebauten atomaren Typen, die niemals lock-free sind,
  • 1 für die eingebauten atomaren Typen, die manchmal lock-free sind,
  • 2 für die eingebauten atomaren Typen, die immer lock-free sind.

Inhaltsverzeichnis

Parameter

obj - Zeiger auf das zu untersuchende atomare Objekt

Rückgabewert

true wenn * obj ein lock-freies Atomic ist, false andernfalls.

Hinweise

Alle atomaren Typen außer std::atomic_flag können unter Verwendung von Mutexen oder anderen Sperroperationen implementiert werden, anstatt die sperrfreien atomaren CPU-Befehle zu nutzen. Atomaren Typen ist es ebenfalls erlaubt, manchmal sperrfrei zu sein: Beispielsweise, wenn nur einige Subarchitekturen sperrfreien atomaren Zugriff für einen bestimmten Typ unterstützen (wie die CMPXCHG16B -Instruktion auf x86-64), kann es sein, dass erst zur Laufzeit bekannt ist, ob Atomare Operationen sperrfrei sind.

Der C++-Standard empfiehlt (verpflichtet aber nicht), dass lockfreie atomare Operationen ebenfalls adressfrei sind, das heißt, geeignet für die Kommunikation zwischen Prozessen, die Shared Memory verwenden.

Beispiel

Diesen Code ausführen 
#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';
}

Mögliche Ausgabe: 

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

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 3249 C++11 atomic_is_lock_free wurde über Zeiger spezifiziert, was
mehrdeutig war und ungültige Zeigerwerte akzeptieren könnte 		Spezifiziert über
atomare Objekte

Siehe auch

prüft, ob das atomare Objekt sperrfrei ist
(öffentliche Elementfunktion von std::atomic<T> )
(C++11)
der sperrfreie boolesche atomare Typ
(Klasse)
[static] (C++17)
zeigt an, dass der Typ immer sperrfrei ist
(öffentliche statische Elementkonstante von std::atomic<T> )
(in C++20 veraltet) (in C++26 entfernt)
spezialisiert atomare Operationen für std::shared_ptr
(Funktionstemplate)
C-Dokumentation für atomic_is_lock_free
C-Dokumentation für ATOMIC_*_LOCK_FREE