0Pricing
C++ Academy · Lektion

Compare-and-Swap-Muster (CAS)

Implementieren Sie sperrenfreie Aktualisierungen mit compare_exchange_weak und compare_exchange_strong.

Compare-and-Swap-Muster (CAS) ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C++ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Das CAS-Primitive

Compare-and-Swap liest, vergleicht und schreibt bedingt atomar. Es ist die Grundlage der meisten lockfreien Algorithmen.

C++ Compare-Exchange

Zwei Varianten in std::atomic:

  • compare_exchange_strong(expected, desired) – erfolgreich, wenn der aktuelle Wert gleich expected ist
  • compare_exchange_weak(expected, desired) – kann grundlos fehlschlagen

Aufbau einer CAS-Schleife

Die klassische CAS-Schleife: lesen, berechnen, Schreiben versuchen. Wiederholen Sie den Vorgang, wenn ein anderer Thread den Wettlauf gewonnen hat.

std::atomic<int> a{0};

int old = a.load();
int next;
do {
    next = compute_new(old);
} while (!a.compare_exchange_weak(old, next));

CAS für atomare Aktualisierungen

Verwenden Sie CAS, wenn der neue Wert vom alten abhängt. Ein einfaches store würde Aktualisierungen nebenläufiger Threads verlieren.

// Atomic max
int current = a.load();
while (newval > current && !a.compare_exchange_weak(current, newval));

Lock-free-Stack: Push

Beim einfachen Push auf einen lockfreien Stack wird ein neuer Knoten mithilfe von CAS am Anfang eingefügt.

struct Node { int value; Node* next; };
std::atomic<Node*> head{nullptr};

void push(int v) {
    Node* n = new Node{v, nullptr};
    n->next = head.load();
    while (!head.compare_exchange_weak(n->next, n));
}

Grundloses Fehlschlagen

compare_exchange_weak kann auch dann fehlschlagen, wenn die Werte übereinstimmen – auf Plattformen wie ARM, auf denen die zugrunde liegende Instruktion fehlschlagen darf. Verwenden Sie es innerhalb von Schleifen und strong, wenn Wiederholungen teuer sind.

Aktualisierungsmuster: Zurücksetzen

Setzen Sie einen Wert nur dann auf einen bekannten Zustand zurück, wenn er sich nicht geändert hat.

int expected = 42;
if (a.compare_exchange_strong(expected, 0)) {
    // a was 42 and is now 0
}

Baustein: Atomarer Zähler

Für einen einfachen Zähler ist fetch_add einfacher und schneller als eine CAS-Schleife.

Baustein: Atomare Markierung

Für ein einfaches boolesches Flag ist std::atomic_flag ressourcenschonender als std::atomic<bool> und unterstützt test_and_set.

Nebenläufigkeit verstehen

Lockfreier Code ist bekanntermaßen schwer zu analysieren. Verwenden Sie gründliche Tests (TSan, Fuzzing), nach Möglichkeit formale Modelle, und bevorzugen Sie bewährte Implementierungen.

Wann CAS verwendet werden sollte

Verwenden Sie CAS, wenn:

  • Mehrere Threads denselben Wert häufig aktualisieren
  • Mutexes aufgrund von Konkurrenz zum Engpass werden
  • Der kritische Abschnitt sehr kurz und einfach ist

Wann CAS nicht verwendet werden sollte

Vermeiden Sie CAS, wenn:

  • Die Aktualisierung mehr als ein paar Operationen benötigt
  • Korrektheit wichtiger als Durchsatz ist
  • Dem Team Erfahrung mit lockfreier Programmierung fehlt

Schnelltest

Warum verwenden wir compare_exchange_weak normalerweise innerhalb einer Schleife?

Zusammenfassung

Compare-and-Swap aktualisiert einen Wert atomar nur dann, wenn er einem erwarteten Wert entspricht. CAS-Schleifen verarbeiten nebenläufige Aktualisierungen ohne Sperren. Verwenden Sie compare_exchange_weak innerhalb von Schleifen und strong für einmalige Versuche.

Häufig gestellte Fragen

Ist die Lektion „Compare-and-Swap-Muster (CAS)“ kostenlos?

Ja — der vollständige Text von „Compare-and-Swap-Muster (CAS)“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C++ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Compare-and-Swap-Muster (CAS)“?

Implementieren Sie sperrenfreie Aktualisierungen mit compare_exchange_weak und compare_exchange_strong. Du übst C++ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C++ Academy zu starten?

Keine Vorkenntnisse erforderlich. C++ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Compare-and-Swap-Muster (CAS)“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C++ Academy-Lektion Code schreiben und ausführen?

Ja. Jede C++ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. std::atomic und Speicherordnungen
  2. Compare-and-Swap-Muster (CAS)
  3. Implementierung einer sperrenfreien Warteschlange
  4. Hazard Pointer und das ABA-Problem
← Zurück zu C++ Academy