0Pricing
C++ Academy · Lektion

std::mutex, lock_guard und unique_lock

Schützen Sie gemeinsam genutzten Zustand mit Mutexen und RAII-Sperrhilfen.

std::mutex, lock_guard und unique_lock 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.

Warum ein Mutex?

Mehrere Threads greifen gleichzeitig auf dieselben Daten zu. Ein Mutex garantiert gegenseitigen Ausschluss: Immer nur ein Thread hält die Sperre.

Grundlagen von std::mutex

Erzeugen, sperren, entsperren. Manuelles Sperren ist fehleranfällig — verwenden Sie immer RAII-Hilfsmittel.

#include <mutex>
std::mutex mtx;

mtx.lock();
// critical section
mtx.unlock();

std::lock_guard: RAII-Sperre

Die einfachste RAII-Sperre. Sie sperrt im Konstruktor und entsperrt im Destruktor. Für kritische Abschnitte ohne Ausnahmen ist sie ideal geeignet.

std::mutex mtx;
int counter = 0;

void increment() {
    std::lock_guard<std::mutex> lock(mtx);
    ++counter;
}

std::scoped_lock (C++17)

Wie lock_guard, kann aber mehrere Mutexes gleichzeitig ohne Deadlock sperren. Bevorzugen Sie ihn in modernem Code.

#include <mutex>
std::scoped_lock lock(mtx1, mtx2, mtx3);  // locks all atomically

std::unique_lock: Flexible Sperre

Mehr Funktionen als lock_guard:

  • Kann innerhalb des Gültigkeitsbereichs entsperrt und erneut gesperrt werden
  • Kann verschoben werden (übertragbares Besitzrecht)
  • Wird mit Bedingungsvariablen verwendet
std::unique_lock<std::mutex> lock(mtx);
lock.unlock();        // release temporarily
// ... do something without the lock ...
lock.lock();           // reacquire

Deadlocks vermeiden

Zwei Threads können einen Deadlock verursachen, wenn sie Sperren in unterschiedlicher Reihenfolge erwerben. Erwerben Sie Sperren in einer einheitlichen globalen Reihenfolge oder verwenden Sie std::scoped_lock mit mehreren Mutexes.

std::lock für mehrere Mutexes

Vor C++17 verwenden Sie std::lock, um mehrere Mutexes atomar zu erwerben. std::scoped_lock ist in C++17 die übersichtlichere Lösung.

Rekursiver Mutex

std::recursive_mutex ermöglicht es einem Thread, denselben Mutex mehrfach zu sperren. Das deutet meist auf Designprobleme hin — überarbeiten Sie das Design stattdessen.

try_lock und timed_mutex

try_lock gibt sofort zurück, wenn die Sperre bereits gehalten wird. std::timed_mutex unterstützt zeitlich begrenzte Sperrversuche.

Leser-Schreiber-Sperre

std::shared_mutex (C++17) erlaubt entweder viele gleichzeitige Leser oder einen exklusiven Schreiber. Verwenden Sie ihn bei überwiegend lesenden Zugriffen.

std::shared_mutex sm;
void read()  { std::shared_lock lk(sm);   /* read */ }
void write() { std::unique_lock lk(sm);   /* write */ }

Kompromiss bei der Granularität

Zu grobe Sperren beeinträchtigen die Nebenläufigkeit. Zu feine Sperren verursachen zusätzlichen Overhead. Ermitteln Sie die Leistung und optimieren Sie entsprechend.

Sperrfreie Alternativen

Bei Szenarien mit hoher Konkurrenz können Sie sperrfreie Datenstrukturen wie Atomics oder sperrfreie Warteschlangen in Betracht ziehen. Sie sind deutlich schwieriger korrekt zu implementieren — verwenden Sie sie nur, wenn sie benötigt und verifiziert sind.

Kurzer Test

Welche RAII-Sperre sollten Sie bevorzugen, wenn Sie mehrere Mutexes gleichzeitig sperren?

Zusammenfassung

Verwenden Sie std::lock_guard für einfache kritische Abschnitte, std::scoped_lock für mehrere Mutexes und std::unique_lock, wenn Sie Flexibilität benötigen, etwa für Bedingungsvariablen oder manuelles Entsperren. Verwenden Sie immer RAII — rufen Sie lock und unlock niemals von Hand auf.

Häufig gestellte Fragen

Ist die Lektion „std::mutex, lock_guard und unique_lock“ kostenlos?

Ja — der vollständige Text von „std::mutex, lock_guard und unique_lock“ 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::mutex, lock_guard und unique_lock“?

Schützen Sie gemeinsam genutzten Zustand mit Mutexen und RAII-Sperrhilfen. 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 „std::mutex, lock_guard und unique_lock“?

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::thread: Zusammenführen und Loslösen
  2. std::mutex, lock_guard und unique_lock
  3. Bedingungsvariablen und Arbeitermuster
  4. Grundlagen von std::async und std::future
← Zurück zu C++ Academy