Wie implementiert man einen ABA-Zähler in C 11 mithilfe von Atomic Compare-and-Swap?

Implementierung des ABA-Zählers mit C 11 CAS

Das ABA-Problem tritt auf, wenn der Wert eines Speicherorts zweimal geändert wird, mit einer dazwischenliegenden Änderung, die festgelegt wird es wieder auf seinen ursprünglichen Wert. Dies kann einen Thread, der sich auf atomare Compare-and-Swap-Operationen (CAS) verlässt, dazu verleiten, zu glauben, dass sich ein Wert nicht geändert hat, obwohl dies tatsächlich der Fall ist.

Um das ABA-Problem zu verhindern, besteht eine gängige Lösung darin, zu erstellen ein Zähler, der mit jeder Änderung des Speicherorts erhöht wird. Dieser Zähler wird zusammen mit der Änderung atomar erhöht, sodass die CAS-Operation prüfen kann, ob sich der Zähler seit der letzten Operation ebenfalls geändert hat.

In C 11 stellt die Funktion std::atomic_compare_exchange_weak eine atomare CAS-Operation bereit. Es ist jedoch nicht möglich, mehrere Variablen gleichzeitig zu ändern, beispielsweise den Wert und den Zähler.

Um einen ABA-Zähler mit C 11 CAS zu implementieren, müssen wir den Zähler und den Wert im angrenzenden Speicher speichern Speicherorte, sodass eine einzelne CAS-Operation beide Werte atomar aktualisieren kann. Dies kann mithilfe einer Struktur mit zwei Mitgliedern erreicht werden, wobei das erste Mitglied der Wert und das zweite Mitglied der Zähler ist:

struct Node {
  std::atomic<int> value;
  std::atomic<int> counter;
};</int></int>

Mit dieser Datenstruktur können wir die Funktion std::atomic_compare_exchange_weak verwenden, um Implementieren Sie den ABA-Zähler:

void modifyValue(Node& node, int newValue) {
  int expectedValue = node.value.load(std::memory_order_relaxed);
  int expectedCounter = node.counter.load(std::memory_order_relaxed);
  bool success;
  do {
    success = node.value.compare_exchange_weak(expectedValue, newValue, std::memory_order_acq_rel);
    success = node.counter.compare_exchange_weak(expectedCounter, expectedCounter + 1, std::memory_order_acq_rel);
  } while (!success);
}

In diesem Beispiel lädt die Funktion „modifyValue“ zunächst den erwarteten Wert und den erwarteten Zähler mithilfe von std::memory_order_relaxed Speicherreihenfolge, die es ermöglicht, dass die Werte nicht in der richtigen Reihenfolge gelesen werden und zu Tearing führen kann.

Die Funktion std::atomic_compare_exchange_weak wird dann verwendet, um den erwarteten Wert und Zähler mit den aktuellen Werten zu vergleichen im Speicherort. Wenn die Werte übereinstimmen, werden der neue Wert und der neue Zähler mithilfe der Speicherreihenfolge std::memory_order_acq_rel an den Speicherort geschrieben. Dadurch wird sichergestellt, dass der Schreibvorgang nach Abschluss des Vorgangs für andere Threads sichtbar ist.

Wenn die Werte nicht übereinstimmen Übereinstimmung schlägt die Funktion „compare_exchange_weak“ fehl und die Schleife wird erneut ausgeführt, wobei der letzte erwartete Wert und Zähler geladen wird, bevor der atomare Austausch erneut versucht wird.

Dies Durch die Implementierung wird sichergestellt, dass der Zähler atomar mit dem Wert erhöht wird, wodurch das ABA-Problem verhindert und sichergestellt wird, dass Threads sich sicher auf die Konsistenz des Werts verlassen können.

Das obige ist der detaillierte Inhalt vonWie implementiert man einen ABA-Zähler in C 11 mithilfe von Atomic Compare-and-Swap?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!