std::atomic und Speicherordnungen
Verwenden Sie std::atomic mit der richtigen Speicherordnung für Korrektheit und Geschwindigkeit.
std::atomic und Speicherordnungen ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.
Über Mutexes hinaus
Sperren serialisieren Zugriffe – sie sind einfach und korrekt, begrenzen aber den Durchsatz. std::atomic bietet lockfreie Bausteine für nebenläufigen Code mit hohem Durchsatz.
Grundlagen von std::atomic
Ein std::atomic<T> kapselt einen Wert und unterstützt atomare Lese-Ändere-Schreib-Operationen.
#include <atomic>
std::atomic<int> counter{0};
counter.fetch_add(1); // atomic increment
int v = counter.load();
counter.store(0);Komfortoperatoren
Bei arithmetischen Typen sind die üblichen Operatoren atomar.
std::atomic<int> n{0};
++n; // atomic increment
n += 5; // atomic add
int v = n; // atomic loadWarum Atomics schwierig sind
Die CPU kann Speicheroperationen über mehrere Kerne hinweg umordnen. Die Speicherreihenfolge legt fest, welche Umordnungen zulässig sind.
Speicherreihenfolgen
Fünf gängige Speicherreihenfolgen:
memory_order_relaxed– atomar, aber ohne Reihenfolgegarantiememory_order_acquire– mit release kombinieren; keine Umordnung danachmemory_order_release– mit acquire kombinieren; keine Umordnung davormemory_order_acq_rel– beidesmemory_order_seq_cst– sequenziell konsistent (Standard)
Sequenzielle Konsistenz: sichere Standardeinstellung
Das standardmäßige seq_cst verhält sich intuitiv – alle Atomics scheinen in einer einzigen globalen Reihenfolge ausgeführt zu werden. Es ist langsamer als schwächere Speicherreihenfolgen, aber leichter zu verstehen.
Acquire-Release-Paarbildung
Verwenden Sie release im Produzenten und acquire im Konsumenten. Nach acquire sind alle Schreibvorgänge sichtbar, die vor dem zugehörigen release erfolgt sind.
std::atomic<bool> ready{false};
int data = 0;
// producer
data = 42;
ready.store(true, std::memory_order_release);
// consumer
while (!ready.load(std::memory_order_acquire));
std::cout << data; // sees 42Relaxed-Reihenfolge
Relaxed-Atomics gewährleisten Atomizität (keine zerrissenen Lesezugriffe), erlauben aber jede Umordnung. Verwenden Sie sie für einfache Zähler, bei denen die Reihenfolge keine Rolle spielt.
Compare-and-Swap
Die Grundlage der meisten lockfreien Algorithmen. compare_exchange_strong(expected, desired) aktualisiert atomar nur dann, wenn der aktuelle Wert gleich expected ist.
std::atomic<int> a{10};
int expected = 10;
bool ok = a.compare_exchange_strong(expected, 20);
// if true, a is now 20; otherwise expected holds the actual current valueSchwaches und starkes CAS
compare_exchange_weak kann auch dann grundlos fehlschlagen, wenn die Werte übereinstimmen. Verwenden Sie es innerhalb von Schleifen (auf manchen Plattformen ist es günstiger) und strong außerhalb von Schleifen.
Lock-free vs. Wait-free
Zwei Fortschrittsgarantien:
- Lock-free – Mindestens ein Thread macht jederzeit Fortschritte
- Wait-free – Jeder Thread macht innerhalb einer begrenzten Zeit Fortschritte
Wann Atomics verwendet werden sollten
Atomics sind nicht immer schneller als Mutexes. Verwenden Sie sie, wenn Sie den kritischen Pfad einfach halten können – etwa für Zähler, Flags oder einfache Zustände. Für komplexe gemeinsam genutzte Zustände sind Mutexes meist sicherer und klarer.
Schnelltest
Welche Speicherreihenfolge bietet die stärksten Garantien, ist aber auch am langsamsten?
Zusammenfassung
std::atomic bietet lockfreie Primitive mit expliziter Speicherreihenfolge. Verwenden Sie standardmäßig memory_order_seq_cst; nutzen Sie acquire/release-Paare für Produzenten-Konsumenten-Muster und relaxed nur für ungeordnete atomare Operationen wie Zähler.
Häufig gestellte Fragen
Ist die Lektion „std::atomic und Speicherordnungen“ kostenlos?
Ja — der vollständige Text von „std::atomic und Speicherordnungen“ 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 „std::atomic und Speicherordnungen“?
Verwenden Sie std::atomic mit der richtigen Speicherordnung für Korrektheit und Geschwindigkeit. 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 1 von 4.
Wie lange dauert die Lektion „std::atomic und Speicherordnungen“?
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
- std::atomic und Speicherordnungen
- Compare-and-Swap-Muster (CAS)
- Implementierung einer sperrenfreien Warteschlange
- Hazard Pointer und das ABA-Problem