Namensräume
Varianten
Aktionen

std::experimental::atomic_shared_ptr<T>::compare_exchange_strong, std::experimental::atomic_shared_ptr<T>::compare_exchange_weak

Von cppreference.com
 
C++
 
Experimentell
 
Erweiterungen für Nebenläufigkeit
 
std::experimental::atomic_shared_ptr
 
bool compare_exchange_weak( std::shared_ptr<T>& expected, const std::shared_ptr<T>& desired,
                            std::memory_order success, std::memory_order failure ) noexcept;
 (1)
bool compare_exchange_weak( std::shared_ptr<T>& expected, std::shared_ptr<T>&& desired,
                            std::memory_order success, std::memory_order failure ) noexcept;
 (2)
bool compare_exchange_weak( std::shared_ptr<T>& expected, const std::shared_ptr<T>& desired,
                            std::memory_order order = std::memory_order_seq_cst ) noexcept;
 (3)
bool compare_exchange_weak( std::shared_ptr<T>& expected, std::shared_ptr<T>&& desired,
                            std::memory_order order = std::memory_order_seq_cst ) noexcept;
 (4)
bool compare_exchange_strong( std::shared_ptr<T>& expected, const std::shared_ptr<T>& desired,
                              std::memory_order success, std::memory_order failure ) noexcept;
 (5)
bool compare_exchange_strong( std::shared_ptr<T>& expected, std::shared_ptr<T>&& desired,
                              std::memory_order success, std::memory_order failure ) noexcept;
 (6)
bool compare_exchange_strong( std::shared_ptr<T>& expected, const std::shared_ptr<T>& desired,
                              std::memory_order order = std::memory_order_seq_cst ) noexcept;
 (7)
bool compare_exchange_strong( std::shared_ptr<T>& expected, std::shared_ptr<T>&& desired,
                              std::memory_order order = std::memory_order_seq_cst ) noexcept;
 (8)

Atomar vergleicht den zugrunde liegenden shared_ptr in *this mit expected, und wenn sie äquivalent sind, ersetzt er den ersteren durch desired (führt eine Lese-Änderungs-Schreib-Operation aus). Andernfalls lädt er den tatsächlichen Wert, der in *this gespeichert ist, in expected (führt eine Lese-Operation aus). Der Ersatz wird wie durch den Kopier- oder Move-Zuweisungsoperator von shared_ptr ausgeführt, je nach Bedarf.

Zwei shared_ptrs sind äquivalent, wenn und nur wenn sie denselben Zeigerwert speichern und die Eigentümerschaft teilen.

Die Speichermodelle für die Lese-Änderungs-Schreib- und Lese-Operationen sind success bzw. failure. Für Überladungen (3,4,7,8) wird order für beide Lese-Änderungs-Schreib- und Lese-Operationen verwendet, außer dass std::memory_order_acquire und std::memory_order_relaxed für die Lese-Operation verwendet werden, wenn order = std::memory_order_acq_rel oder order = std::memory_order_release ist.

Die schwachen Versionen (1-4) können fehlschlagen (spuriously).

Inhalt

[edit] Parameter

expected - Referenz auf den Wert, von dem erwartet wird, dass er im atomaren Objekt gefunden wird
desired - der Wert, der in das atomare Objekt geschrieben werden soll, wenn er wie erwartet ist
erfolgreich - die Speicher-Synchronisations-Ordnung für die Lese-Änderungs-Schreib-Operation, wenn der Vergleich erfolgreich ist. Alle Werte sind zulässig
failure - die Speicher-Synchronisations-Ordnung für die Lese-Operation, wenn der Vergleich fehlschlägt. Kann nicht std::memory_order_release oder std::memory_order_acq_rel sein und darf keine stärkere Ordnung als success angeben
Reihenfolge - die Speicher-Synchronisationsreihenfolge für beide Operationen

[edit] Rückgabewert

true, wenn der zugrunde liegende atomare Wert geändert wurde, andernfalls false.

[edit] Hinweise

Alle Änderungen am atomic_shared_ptr-Objekt selbst und alle zugehörigen Inkremente von use_count sind garantiert atomar durchzuführen. Zugehörige Dekremente von use_count erfolgen nach der atomaren Operation, müssen aber nicht Teil davon sein. Alle zugehörigen Zerstörungs- oder Freigabeoperationen erfolgen nach der atomaren Operation und sind kein Teil davon.

Wenn die Compare-Exchange-Operation true zurückgibt, wird expected nach dem atomaren Update-Schritt nicht mehr verwendet. Wenn sie false zurückgibt, wird expected mit dem vorhandenen Wert aktualisiert, der beim versuchten atomaren Update aus dem atomic_shared_ptr-Objekt gelesen wurde. Die use_count-Aktualisierung, die der Zuweisung zu expected entspricht, ist Teil der atomaren Operation, aber die Zuweisung zu expected selbst muss nicht Teil der atomaren Operation sein.

Für Überladungen (1,3,5,7) wird desired nach dem atomaren Update-Schritt nicht mehr verwendet.

Für Überladungen (2,4,6,8) wird desired nur dann von woandersher bewegt, wenn die Compare-Exchange-Operation true zurückgibt; das Bewegen findet nach dem atomaren Update-Schritt statt.

[edit] Anmerkungen

Die schwachen Formen (1-4) der Funktionen dürfen fehlschlagen (spuriously), d.h., sie können so handeln, als ob *this und expected nicht äquivalent sind, auch wenn sie es sind. Wenn eine Compare-and-Exchange-Operation in einer Schleife verwendet wird, erzielt die schwache Version auf einigen Plattformen eine bessere Leistung.

[edit] Siehe auch

(in C++20 veraltet)(in C++26 entfernt)
 spezialisiert atomare Operationen für std::shared_ptr
(Funktionsschablone) [bearbeiten]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/experimental/atomic_shared_ptr/compare_exchange&oldid=157716"