CKTIS / C++
std::shared_mutex — gemeinsames und exklusives Sperren
Mit std::shared_mutex können mehrere Threads gleichzeitig gemeinsamen Besitz oder ein Thread exklusiven Besitz haben. Verwenden Sie std::shared_lock zum Lesen und std::unique_lock zum Schreiben und halten Sie sich bei jedem Zugriff auf die geschützten Daten an dasselbe Protokoll.
Version: C++23; repository compiler flag, production runtime not attested
Syntax
#include <shared_mutex>
#include <mutex>
std::shared_mutex m;
// In separate scopes:
{ std::shared_lock<std::shared_mutex> read_lock(m); }
{ std::unique_lock<std::shared_mutex> write_lock(m); }std::shared_mutex aus <shared_mutex> ist ein nicht-rekursiver Mutex. Im gemeinsamen Modus sind mehrere Besitzer gleichzeitig erlaubt; im exklusiven Modus sind alle anderen Besitzer ausgeschlossen. Üblicherweise wird unter gemeinsamem Besitz gelesen und unter exklusivem Besitz geändert. Der Mutex selbst kontrolliert den Zugriff auf Variablen nicht: Ihr Code muss dieses Protokoll konsequent einhalten.
lock() und unlock() verwalten den exklusiven Besitz, während lock_shared() und unlock_shared() den gemeinsamen Besitz verwalten. Die blockierenden Operationen warten, bis der Besitz erworben werden kann. try_lock() und try_lock_shared() versuchen, den Besitz ohne Warten zu erwerben, und geben bool zurück; sie können auch ohne tatsächliche Sperrung scheitern. false beweist daher nicht, dass ein anderer Thread den Mutex besitzt.
Verwenden Sie vorzugsweise RAII statt manuellem Entsperren: std::shared_lock<std::shared_mutex> aus <shared_mutex> für Leser und std::unique_lock<std::shared_mutex> aus <mutex> für Schreiber. Diese Objekte geben eine gehaltene Sperre beim Verlassen ihres Gültigkeitsbereichs frei, auch während der Weitergabe einer Ausnahme. Gemeinsamer Besitz bietet nicht die Exklusivität, die für gewöhnliche Änderungen an gemeinsam genutzten Daten erforderlich ist.
Versuchen Sie nicht, in einem Thread, der denselben Mutex bereits besitzt, erneut irgendeine Art von Besitz zu erwerben: Das Verhalten ist undefiniert. Dazu zählt auch der Versuch, exklusiven Besitz zu erlangen, ohne den gemeinsamen Besitz freizugeben. Entsperren und erneutes Sperren ist kein atomarer Moduswechsel – dazwischen können sich Daten ändern. Zerstören Sie keinen gehaltenen Mutex und lassen Sie keinen Thread enden, während er den Mutex noch besitzt.
Das Beispiel trennt das Schreiben durch join() vom Lesen und schützt jeden Zugriff auf value mit der passenden Sperre. Die Leser können gleichzeitig ausgeführt werden, müssen es aber nicht; sie speichern ihre Ergebnisse in getrennten Variablen. Die Ausgabe nach beiden join()-Aufrufen liefert das deterministische Ergebnis 42 42.
Beispiele
#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <thread>
int main() {
std::shared_mutex mutex;
int value = 0;
std::thread writer([&] {
std::unique_lock<std::shared_mutex> lock(mutex);
value = 42;
});
writer.join();
int first = 0;
int second = 0;
std::thread reader1([&] {
std::shared_lock<std::shared_mutex> lock(mutex);
first = value;
});
std::thread reader2([&] {
std::shared_lock<std::shared_mutex> lock(mutex);
second = value;
});
reader1.join();
reader2.join();
std::cout << first << ' ' << second << '\n';
}
Ergebnis
42 42
Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.
Quellen
- C++ working draft — Concurrency support library [thread]
- C++ working draft — Class shared_mutex [thread.sharedmutex.class]
- C++ working draft — Shared mutex types [thread.sharedmutex.requirements]
- C++ working draft — Class template shared_lock [thread.lock.shared]
- C++ working draft — Class template unique_lock [thread.lock.unique]