std::atomic<std::weak_ptr>
| Definiert in 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> erlaubt Benutzern, weak_ptr-Objekte atomar zu manipulieren.
Wenn mehrere Threads auf dasselbe std::weak_ptr-Objekt ohne Synchronisation zugreifen und einer dieser Zugriffe eine nicht-const Memberfunktion von weak_ptr verwendet, tritt ein Datenwettlauf auf, es sei denn, alle solchen Zugriffe werden über eine Instanz von std::atomic<std::weak_ptr> durchgeführt.
Assoziierte use_count-Inkremente sind garantiert Teil der atomaren Operation. Assoziierte use_count-Dekremente werden nach der atomaren Operation sequenziert, müssen aber nicht Teil davon sein, außer bei der use_count-Änderung beim Überschreiben von expected in einem fehlgeschlagenen CAS. Jegliche assoziierte Löschung und Deallokation werden nach dem atomaren Aktualisierungsschritt sequenziert und sind nicht Teil der atomaren Operation.
Beachten Sie, dass der von std::weak_ptr und std::shared_ptr verwendete Kontrollblock threadsicher ist: Unterschiedliche nicht-atomare std::weak_ptr-Objekte können gleichzeitig von mehreren Threads mit veränderbaren Operationen, wie operator= oder reset, zugegriffen werden, auch wenn diese Instanzen Kopien sind oder intern denselben Kontrollblock teilen.
Der Typ T darf ein unvollständiger Typ sein.
[edit] Member types
| Mitgliedertyp | Definition |
value_type
|
std::weak_ptr<T> |
[edit] Member functions
Alle nicht spezialisierten std::atomic-Funktionen werden auch von dieser Spezialisierung bereitgestellt, und keine zusätzlichen Memberfunktionen.
atomic<weak_ptr<T>>::atomic
| constexpr atomic() noexcept = default; |
(1) | |
| atomic(std::weak_ptr<T> desired) noexcept; |
(2) | |
| atomic(const atomic&) = delete; |
(3) | |
weak_ptr<T> mit einem standardkonstruierten Wert.weak_ptr<T> mit einer Kopie von desired. Wie bei jedem std::atomic-Typ ist die Initialisierung keine atomare Operation.atomic<weak_ptr<T>>::operator=
| void operator=(const atomic&) = delete; |
(1) | |
| void operator=(std::weak_ptr<T> desired) noexcept; |
(2) | |
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 durch den Wert von desired, als ob durch p.swap(desired), wobei p das zugrundeliegende std::weak_ptr<T> ist. Der Speicher 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
| std::weak_ptr<T> load(std::memory_order order = std::memory_order_seq_cst) const noexcept; |
||
Gibt atomar eine Kopie des zugrundeliegenden std::weak_ptr<T> zurück. Der Speicher 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; |
||
Äquivalent zu return load();.
atomic<weak_ptr<T>>::exchange
| std::weak_ptr<T> exchange(std::weak_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst) noexcept; |
||
Ersetzt atomar das zugrundeliegende std::weak_ptr<T> durch desired, als ob 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 Tausch hatte. Der Speicher wird gemäß order geordnet. Dies ist eine atomare Lese-Änderungs-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) | |
expected speichert und sich den Besitz mit ihm teilt, oder wenn sowohl das zugrundeliegende als auch expected leer sind, wird desired in das zugrundeliegende std::weak_ptr<T> zugewiesen, und es wird true zurückgegeben und der Speicher gemäß success geordnet. Andernfalls wird der Wert von dem zugrundeliegenden std::weak_ptr<T> nach expected kopiert, false zurückgegeben und der Speicher gemäß failure geordnet. Das Verhalten ist undefiniert, wenn failure std::memory_order_release oder std::memory_order_acq_rel ist. Im Erfolgsfall ist die Operation eine atomare Lese-Änderungs-Schreib-Operation auf *this und expected wird nach der atomaren Aktualisierung nicht zugegriffen. Im Fehlerfall ist die Operation eine atomare Lese-Operation auf *this und expected wird mit dem aktuellen Wert, der aus dem atomaren Objekt gelesen wurde, aktualisiert. Diese Aktualisierung des use_count von expected ist Teil dieser atomaren Operation, obwohl der Schreibvorgang selbst (und jegliche nachfolgende Deallokation/Zerstörung) nicht zwingend erforderlich ist.fail_order dasselbe ist wie order, mit der Ausnahme, dass std::memory_order_acq_rel durch std::memory_order_acquire und std::memory_order_release durch std::memory_order_relaxed ersetzt wird.fail_order dasselbe ist wie order, mit der Ausnahme, dass std::memory_order_acq_rel durch std::memory_order_acquire und std::memory_order_release durch std::memory_order_relaxed ersetzt wird.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, wenn 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, auch wenn die zugrundeliegende Implementierung fehlerhaft aufwacht.
Der Speicher wird gemäß order geordnet. Das Verhalten ist undefiniert, wenn order std::memory_order_release oder std::memory_order_acq_rel ist.
Hinweise: Zwei std::weak_ptrs sind äquivalent, wenn sie denselben Zeiger speichern und entweder den Besitz teilen oder beide leer sind.
atomic<weak_ptr<T>>::notify_one
| void notify_one() noexcept; |
||
Führt eine atomare Benachrichtigungsoperation aus.
Wenn ein Thread in atomaren Warteoperationen (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 aus.
Entblockiert alle Threads, die in atomaren Warteoperationen (d.h. wait()) auf *this blockiert sind, falls vorhanden; andernfalls geschieht nichts.
[edit] Member constants
Die einzige standardmäßige std::atomic-Memberkonstante is_always_lock_free wird auch von dieser Spezialisierung bereitgestellt.
atomic<weak_ptr<T>>::is_always_lock_free
| static constexpr bool is_always_lock_free = /*implementierungsdefiniert*/; |
||
[edit] Example
| Dieser Abschnitt ist unvollständig Grund: kein Beispiel |
[edit] See also
| (C++11) |
atomares Klassentemplate und Spezialisierungen für boolesche, integrale, Gleitkomma-(seit C++20) und Zeigertypen (Klassen-Template) |
