Namensräume
Varianten
Aktionen

std::atomic_is_lock_free, ATOMIC_xxx_LOCK_FREE

Von cppreference.com
< cpp‎ | atomic
 
C++
 
Bibliothek für nebenläufige Programmierung
Threads
(C++11)
(C++20)
(C++17)(C++17)
this_thread Namespace
(C++11)
(C++11)
(C++11)
(C++11)
Kooperatives Beenden
Gegenseitiger Ausschluss
(C++11)
(C++11)
(C++17)
Allgemeines Sperrungsmanagement
(C++11)
(C++11)
(C++17)
(C++11)
(C++14)
(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)
Bedingungsvariablen
(C++11)
(C++11)
(C++11)
(C++11)
Semaphoren
(C++20)(C++20)
Latches und Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Sichere Wiederherstellung
(C++26)
(C++26)
(C++26)
Hazard Pointer
(C++26)
(C++26)
(C++26)
Atomare Typen
(C++11)
(C++20)
(C++11)
Initialisierung von atomaren Typen
(C++11)(veraltet in C++20)
(C++11)(veraltet in C++20)
(C++11)
Speicherordnung
(C++11)
(C++11)(deprecated in C++26)
(C++11)
(C++11)
Freie Funktionen für atomare Operationen
(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)
Freie Funktionen für atomare Flags
(C++11)(C++11)
(C++11)(C++11)
(C++20)(C++20)
(C++20)(C++20)
(C++20)
(C++20)
 
Definiert in 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     /* nicht spezifiziert */

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

#define ATOMIC_POINTER_LOCK_FREE  /* nicht spezifiziert */
 (3) (seit C++11)
#define ATOMIC_CHAR8_T_LOCK_FREE  /* nicht spezifiziert */
 (4) (seit C++20)
1,2) Ermittelt, ob das durch obj zeigende atomare Objekt lock-free implementiert ist, als ob obj->is_lock_free() aufgerufen würde. Bei jeder 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.

Inhalt

[bearbeiten] Parameter

obj - Zeiger auf das zu untersuchende atomare Objekt

[bearbeiten] Rückgabewert

true, wenn *obj ein lock-free atomares Objekt ist, andernfalls false.

[bearbeiten] Hinweise

Alle atomaren Typen außer std::atomic_flag können mithilfe von Mutexen oder anderen Sperroperationen anstelle von lock-free atomaren CPU-Instruktionen implementiert werden. Atomare Typen dürfen auch manchmal lock-free sein: Wenn zum Beispiel nur einige Subarchitekturen lock-free atomaren Zugriff für einen bestimmten Typ unterstützen (wie die CMPXCHG16B-Instruktion auf x86-64), ist möglicherweise nicht zur Laufzeit bekannt, ob Atome lock-free sind.

Der C++-Standard empfiehlt (fordert aber nicht), dass lock-free atomare Operationen auch adressfrei sind, d.h. für die Kommunikation zwischen Prozessen mithilfe von Shared Memory geeignet sind.

[bearbeiten] Beispiel

Führen Sie diesen Code aus
#include <atomic>
#include <iostream>
#include <utility>
 
struct A { int a[100]; };
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

[bearbeiten] Fehlerberichte

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

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

[bearbeiten] Siehe auch

 prüft, ob das atomare Objekt lock-frei ist
(öffentliche Memberfunktion von std::atomic<T>) [bearbeiten]
(C++11)
 der sperrfreie boolesche atomare Typ
(Klasse) [bearbeiten]
[static] (C++17)
 zeigt an, dass der Typ immer lock-frei ist
(öffentliche statische Memberkonstante von std::atomic<T>) [bearbeiten]
(in C++20 veraltet)(in C++26 entfernt)
 spezialisiert atomare Operationen für std::shared_ptr
(function template)
C-Dokumentation für atomic_is_lock_free
C-Dokumentation für ATOMIC_*_LOCK_FREE
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/atomic/atomic_is_lock_free&oldid=171245"