std::atomic_compare_exchange_weak, std::atomic_compare_exchange_strong, std::atomic_compare_exchange_weak_explicit, std::atomic_compare_exchange_strong_explicit

<metanoindex/>

 

C++

Sprache

Concepts

Utilities-Bibliothek

Strings Bibliothek

Container-Bibliothek

Algorithmen-Bibliothek

Iteratoren Bibliothek

Numerik-Bibliothek

Input / Output-Bibliothek

Lokalisierungen Bibliothek

Reguläre Ausdrücke Bibliothek (C++11)

Atomare Operationen Bibliothek (C++11)

Thread Support-Bibliothek (C++11)

 

Atomare Operationen Bibliothek

Types Original: Types The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

atomic (C++11)

atomic_is_lock_free (C++11)

Funktionen Original: Functions The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

atomic_store atomic_store_explicit (C++11) (C++11)

atomic_load atomic_load_explicit (C++11) (C++11)

atomic_exchange atomic_exchange_explicit (C++11) (C++11)

atomic_compare_exchange_weak atomic_compare_exchange_weak_explicit atomic_compare_exchange_strong atomic_compare_exchange_strong_explicit (C++11) (C++11) (C++11) (C++11)

atomic_fetch_add atomic_fetch_add_explicit (C++11) (C++11)

atomic_fetch_sub atomic_fetch_sub_explicit (C++11) (C++11)

atomic_fetch_and atomic_fetch_and_explicit (C++11) (C++11)

atomic_fetch_or atomic_fetch_or_explicit (C++11) (C++11)

atomic_fetch_xor atomic_fetch_xor_explicit (C++11) (C++11)

Atomic Fahnen Original: Atomic flags The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

atomic_flag (C++11)

atomic_flag_test_and_set atomic_flag_test_and_set_explicit (C++11) (C++11)

atomic_flag_clear atomic_flag_clear_explicit (C++11) (C++11)

Initialisierung Original: Initialization The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

atomic_init (C++11)

ATOMIC_VAR_INIT (C++11)

ATOMIC_FLAG_INIT (C++11)

Speicher Bestellung Original: Memory ordering The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

memory_order (C++11)

kill_dependency (C++11)

atomic_thread_fence (C++11)

atomic_signal_fence (C++11)

 

<tbody> </tbody>

definiert in Header <atomic>
template< class T > bool atomic_compare_exchange_weak( std::atomic<T>* obj, T* expected, T desired ); template< class T > bool atomic_compare_exchange_weak( volatile std::atomic<T>* obj, T* expected, T desired );	(1)	(seit C++11)
template< class T > bool atomic_compare_exchange_strong( std::atomic<T>* obj, T* expected, T desired ); template< class T > bool atomic_compare_exchange_strong( volatile std::atomic<T>* obj, T* expected, T desired );	(2)	(seit C++11)
template< class T > bool atomic_compare_exchange_weak_explicit( std::atomic<T>* obj, T* expected, T desired, std::memory_order succ, std::memory_order fail ); template< class T > bool atomic_compare_exchange_weak_explicit( volatile std::atomic<T>* obj, T* expected, T desired, std::memory_order succ, std::memory_order fail );	(3)	(seit C++11)
template< class T > bool atomic_compare_exchange_strong_explicit( std::atomic<T>* obj, T* expected, T desired, std::memory_order succ, std::memory_order fail ); template< class T > bool atomic_compare_exchange_strong_explicit( volatile std::atomic<T>* obj, T* expected, T desired, std::memory_order succ, std::memory_order fail );	(4)	(seit C++11)

Atomar vergleicht den Wert, auf den durch obj mit dem Wert, auf den durch expected, und wenn diese gleich sind, ersetzt die früheren mit desired (durchführt Lese-Modifizieren-Schreib-Operation). Andernfalls lädt den aktuellen Wert, auf den obj in *expected (führt im Leerlauf) .

Original:

Atomically compares the value pointed to by obj with the value pointed to by expected, and if those are equal, replaces the former with desired (performs read-modify-write operation). Otherwise, loads the actual value pointed to by obj into *expected (performs load operation).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Die Speichermodule Modelle für die Lese-Modifizieren-Schreiben und Ladeoperationen sind succ und fail sind. Die (1-2)-Versionen verwenden std::memory_order_seq_cst standardmäßig .

Original:

The memory models for the read-modify-write and load operations are succ and fail respectively. The (1-2) versions use std::memory_order_seq_cst by default.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Die schwachen Formen ((1) und (3)) der Funktionen dürfen spuriously scheitern, das ist, als ob *obj != *expected handeln, auch wenn sie gleich sind. Wenn ein Vergleichs-und Austausch in einer Schleife ist, wird die schwache Version eine bessere Leistung auf einigen Plattformen. Wenn ein schwacher Vergleichen und-Austausch würde eine Schleife und eine starke eins erfordern würde nicht, ist der Starke vorzuziehen .

Original:

The weak forms ((1) and (3)) of the functions are allowed to fail spuriously, that is, act as if *obj != *expected even if they are equal. When a compare-and-exchange is in a loop, the weak version will yield better performance on some platforms. When a weak compare-and-exchange would require a loop and a strong one would not, the strong one is preferable.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Diese Funktionen werden in Form von Elementfunktionen std::atomic definiert:

Original:

These functions are defined in terms of member functions of std::atomic:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

1) obj->compare_exchange_weak(exp, desr)

2) obj->compare_exchange_strong(exp, desr)

3) obj->compare_exchange_weak(exp, desr, succ, fail)

4) obj->compare_exchange_strong(exp, desr, succ, fail)

Parameter

obj	-	Zeiger auf die atomare Objekt zu testen und zu modifizieren Original: pointer to the atomic object to test and modify The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
expected	-	Zeiger auf den Wert soll im atomaren Objekt gefunden werden Original: pointer to the value expected to be found in the atomic object The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
desired	-	der Wert in der atomaren Objekt zu speichern, wenn es wie erwartet Original: the value to store in the atomic object if it is as expected The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
succ	-	der Speicher sycnhronization Bestellsystem für die Lese-Modifizieren-Schreib-Operation, wenn der Vergleich erfolgreich ist. Alle Werte sind zulässig . Original: the memory sycnhronization ordering for the read-modify-write operation if the comparison succeeds. All values are permitted. The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
fail	-	der Speicher sycnhronization Bestellsystem für die Ladeoperation, wenn der Vergleich fehlschlägt. Kann nicht sein std::memory_order_release oder std::memory_order_ack_rel und können nicht angeben, stärker Bestellung als succ Original: the memory sycnhronization ordering for the load operation if the comparison fails. Cannot be std::memory_order_release or std::memory_order_ack_rel and cannot specify stronger ordering than succ The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Rückgabewert

Das Ergebnis des Vergleichs: true wenn *obj gleich *exp war, ansonsten false .

Original:

The result of the comparison: true if *obj was equal to *exp, false otherwise.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Ausnahmen

noexcept specification:  

<tbody> </tbody>

noexcept

  (seit C++11)

Beispiel

Dieses Beispiel zeigt, wie und zu vergleichen-Austausch verwendet werden kann, um Lock-freie append einer einfach verketteten Liste zu implementieren

Original:

This example shows how compare-and-exchange may be used to implement lock-free append to a singly linked list

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

void append(list* s, node* n)
{
    node* head;
    do {
        head = s->head;
        n->next = head;
    } while(! std::atomic_compare_exchange_weak(s->head, head, n));
}

Siehe auch

compare_exchange_weak compare_exchange_strong	atomar vergleicht den Wert des atomaren Objekt mit nicht-elementare Argument und führt atomaren Austausch wenn gleiche oder atomare Last, wenn nicht Original: atomically compares the value of the atomic object with non-atomic argument and performs atomic exchange if equal or atomic load if not The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (öffentliche Elementfunktion of std::atomic)
atomic_exchange atomic_exchange_explicit (C++11) (C++11)	atomar ersetzt den Wert des atomaren Objekt mit nicht-elementare Argument und gibt den alten Wert des atomaren Original: atomically replaces the value of the atomic object with non-atomic argument and returns the old value of the atomic The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (Funktions-Template)
std::atomic_compare_exchange_weak(std::shared_ptr) std::atomic_compare_exchange_strong(std::shared_ptr)	spezialisiert atomare Operationen für std :: shared_ptr Original: specializes atomic operations for std::shared_ptr The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (Funktions-Template)
C documentation for atomic_compare_exchange, atomic_compare_exchange_explicit