Namespaces
Variants

std:: atomic <std::weak_ptr>

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::weak_ptr
Definiert im Header <memory>
template < class T > struct std:: atomic < std:: weak_ptr < T >> ;
(seit C++20)

Die partielle Template-Spezialisierung von std::atomic für std:: weak_ptr < T > ermöglicht es Benutzern, weak_ptr-Objekte atomar zu manipulieren.

Wenn mehrere Ausführungsstränge auf dasselbe std::weak_ptr -Objekt zugreifen ohne Synchronisierung und einer dieser Zugriffe eine nicht-konstante Memberfunktion von weak_ptr verwendet, dann tritt ein Datenwettlauf auf, es sei denn, alle derartigen Zugriffe erfolgen über eine Instanz von std:: atomic < std:: weak_ptr > .

Assoziierte use_count Inkremente sind garantiert Teil der atomaren Operation. Assoziierte use_count Dekremente sind nach der atomaren Operation sequenziert, müssen jedoch nicht Teil davon sein, außer bei der use_count Änderung beim Überschreiben von expected in einer fehlgeschlagenen CAS-Operation. Jede assoziierte Löschung und Freigabe ist nach dem atomaren Aktualisierungsschritt sequenziert und nicht Teil der atomaren Operation.

Beachten Sie, dass der Kontrollblock, der von std::weak_ptr und std::shared_ptr verwendet wird, threadsicher ist: Unterschiedliche nicht-atomare std::weak_ptr -Objekte können mit veränderlichen Operationen, wie operator = oder reset , gleichzeitig von mehreren Threads zugreifen, selbst wenn diese Instanzen Kopien sind oder intern denselben Kontrollblock teilen.

Der Typ T kann ein unvollständiger Typ sein.

Inhaltsverzeichnis

Mitgliedertypen

Mitgliedstyp Definition
value_type std:: weak_ptr < T >

Memberfunktionen

Alle nicht-spezialisierten std::atomic Funktionen werden auch von dieser Spezialisierung bereitgestellt, und es gibt keine zusätzlichen Member-Funktionen.

atomic<weak_ptr<T>>:: atomic

constexpr atomic ( ) noexcept = default ;
(1)
atomic ( std:: weak_ptr < T > desired ) noexcept ;
(2)
atomic ( const atomic & ) = delete ;
(3)
1) Initialisiert den zugrundeliegenden weak_ptr<T> mit dem Standardkonstruktor-Wert.
2) Initialisiert den zugrundeliegenden weak_ptr<T> mit einer Kopie von desired . Wie bei jedem std::atomic -Typ ist die Initialisierung kein atomarer Vorgang.
3) Atomare Typen sind nicht kopier-/verschiebekonstruierbar.

atomic<weak_ptr<T>>:: operator=

void operator = ( const atomic & ) = delete ;
(1)
void operator = ( std:: weak_ptr < T > desired ) noexcept ;
(2)
1) Atomare Typen sind nicht kopier-/verschiebezuweisbar.
2) Wertzuweisung, äquivalent zu store ( desired ) .

atomic<weak_ptr<T>>:: is_lock_free

bool is_lock_free ( ) const noexcept ;

Gibt true zurück, wenn die atomaren Operationen auf allen Objekten dieses Typs sperrfrei sind, andernfalls false.

atomic<weak_ptr<T>>:: store

void store ( std:: weak_ptr < T > desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;

Ersetzt atomar den Wert von * this mit dem Wert von desired wie durch p. swap ( desired ) , wobei p das zugrundeliegende std:: weak_ptr < T > ist. Der Speicherzugriff wird gemäß order geordnet. Das Verhalten ist undefiniert, wenn order std::memory_order_consume , std::memory_order_acquire oder std::memory_order_acq_rel ist.

atomic<weak_ptr<T>>:: load

Gibt atomar eine Kopie des zugrunde liegenden std:: weak_ptr < T > zurück. Der Speicherzugriff wird gemäß order geordnet. Das Verhalten ist undefiniert, wenn order std::memory_order_release oder std::memory_order_acq_rel ist.

atomic<weak_ptr<T>>:: operator std::weak_ptr<T>

operator std:: weak_ptr < T > ( ) const noexcept ;

Entspricht return load ( ) ; .

atomic<weak_ptr<T>>:: exchange

Ersetzt atomar das zugrundeliegende std:: weak_ptr < T > mit desired wie durch p. swap ( desired ) , wobei p das zugrundeliegende std:: weak_ptr < T > ist, und gibt eine Kopie des Wertes zurück, den p unmittelbar vor dem Austausch hatte. Der Speicherzugriff wird gemäß order geordnet. Dies ist eine atomare Lese-Modifizier-Schreib-Operation.

atomic<weak_ptr<T>>:: compare_exchange_weak, compare_exchange_strong

bool compare_exchange_strong ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > desired,
std:: memory_order success, std:: memory_order failure ) noexcept ;
(1)
bool compare_exchange_weak ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > desired,
std:: memory_order success, std:: memory_order failure ) noexcept ;
(2)
bool compare_exchange_strong ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;
(3)
bool compare_exchange_weak ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;
(4)
**Anmerkung:** Da der Text innerhalb der ` ` Tags als Code betrachtet wird und C++-spezifische Begriffe nicht übersetzt werden sollen, wurde nur der strukturelle HTML-Code beibehalten. Die Funktionssignaturen und C++-Schlüsselwörter bleiben unverändert auf Englisch, wie in den Anforderungen spezifiziert.
1) Wenn der zugrundeliegende std:: weak_ptr < T > denselben Zeigerwert wie expected speichert und Besitz mit ihm teilt, oder wenn sowohl der zugrundeliegende als auch expected leer sind, weist desired dem zugrundeliegenden std:: weak_ptr < T > zu, gibt true zurück und ordnet den Speicher gemäß success , andernfalls weist es den zugrundeliegenden std:: weak_ptr < T > an expected zu, gibt false zurück und ordnet den Speicher gemäß failure . Das Verhalten ist undefiniert, wenn failure std::memory_order_release oder std::memory_order_acq_rel ist. Bei Erfolg ist der Vorgang eine atomare Lese-Modifizier-Schreib-Operation auf * this und expected wird nach der atomaren Aktualisierung nicht mehr zugegriffen. Bei Misserfolg ist der Vorgang eine atomare Ladeoperation auf * this und expected wird mit dem vorhandenen Wert aus dem atomaren Objekt aktualisiert. Diese Aktualisierung des use_count von expected ist Teil dieser atomaren Operation, obwohl der Schreibvorgang selbst (und jede nachfolgende Freigabe/Zerstörung) nicht zwingend atomar sein muss.
2) Gleich wie (1) , kann aber auch fälschlicherweise fehlschlagen.
3) Entspricht: return compare_exchange_strong ( expected, desired, order, fail_order ) ; , wobei fail_order gleich order ist, außer dass std::memory_order_acq_rel ersetzt wird durch std::memory_order_acquire und std::memory_order_release ersetzt wird durch std::memory_order_relaxed .
4) Entspricht: return compare_exchange_weak ( expected, desired, order, fail_order ) ; , wobei fail_order gleich order ist, außer dass std::memory_order_acq_rel ersetzt wird durch std::memory_order_acquire und std::memory_order_release ersetzt wird durch std::memory_order_relaxed .

atomic<weak_ptr<T>>:: wait

void wait ( std:: weak_ptr < T > old
std:: memory_order order = std:: memory_order_seq_cst ) const noexcept ;

Führt eine atomare Warteoperation aus.

Vergleicht load ( order ) mit old und blockiert, falls sie äquivalent sind, bis * this durch notify_one() oder notify_all() benachrichtigt wird. Dies wird wiederholt, bis sich load ( order ) ändert. Diese Funktion gibt garantiert nur zurück, wenn sich der Wert geändert hat, selbst wenn die zugrundeliegende Implementierung fälschlicherweise entblockt.

Der Speicherzugriff wird gemäß order geordnet. Das Verhalten ist undefiniert, wenn order std::memory_order_release oder std::memory_order_acq_rel ist.

Hinweis: Zwei std::weak_ptr sind äquivalent, wenn sie denselben Zeiger speichern und entweder gemeinsamen Besitz teilen oder beide leer sind.

atomic<weak_ptr<T>>:: notify_one

void notify_one ( ) noexcept ;

Führt eine atomare Benachrichtigungsoperation aus.

Falls ein Thread in atomaren Wartevorgängen (d.h. wait() ) auf * this blockiert ist, wird mindestens ein solcher Thread entblockiert; andernfalls geschieht nichts.

atomic<weak_ptr<T>>:: notify_all

void notify_all ( ) noexcept ;

Führt eine atomare Benachrichtigungsoperation durch.

Entsperrt alle Threads, die in atomaren Wartevorgängen (d.h. wait() ) auf * this blockiert sind, falls vorhanden; andernfalls tut sie nichts.

Memberkonstanten

Die einzige standardmäßige std::atomic Member-Konstante is_always_lock_free wird ebenfalls von dieser Spezialisierung bereitgestellt.

atomic<weak_ptr<T>>:: is_always_lock_free

static constexpr bool is_always_lock_free = /*implementierungsdefiniert*/ ;

Beispiel

Dieser Abschnitt ist unvollständig
Grund: Kein Beispiel

Siehe auch

(C++11)
Atomic-Klassen-Template und Spezialisierungen für bool, Ganzzahl, Gleitkomma, (seit C++20) und Zeigertypen
(Klassen-Template)