C++ benannte Anforderungen: SharedMutex (seit C++17)
Die Anforderungen an SharedMutex erweitern die Anforderungen an Mutex um den Modus des gemeinsamen Sperrbesitzes.
[bearbeiten] Anforderungen
Zusätzlich unterstützt ein Objekt m vom Typ SharedMutex einen weiteren Besitztumsmodus: den gemeinsamen Modus. Mehrere Threads (oder allgemeiner gesagt, Ausführungsagenten) können diesen Mutex gleichzeitig im gemeinsamen Modus besitzen, aber kein Thread darf einen gemeinsamen Besitz erlangen, wenn ein Thread ihn im exklusiven Modus besitzt, und kein Thread darf einen exklusiven Besitz erlangen, wenn ein Thread ihn im gemeinsamen Modus besitzt. Wenn mehr als die implementierungsdefinierte Anzahl von Threads (nicht weniger als 10000) eine gemeinsame Sperre halten, blockiert ein weiterer Versuch, den Mutex im gemeinsamen Modus zu erwerben, bis die Anzahl der gemeinsamen Besitzer unter diesen Schwellenwert fällt.
- Der Ausdruck m.lock_shared() hat folgende Eigenschaften:
- Verhält sich als atomare Operation.
- Blockiert den aufrufenden Thread, bis ein gemeinsamer Besitz des Mutex erlangt werden kann.
- Vorherige m.unlock()-Operationen auf demselben Mutex synchronisieren sich mit dieser Sperroperation (entspricht std::memory_order Acquire-Release).
- Das Verhalten ist undefiniert, wenn der aufrufende Thread den Mutex bereits in irgendeinem Modus besitzt.
- Wenn eine Ausnahme ausgelöst wird, wird die gemeinsame Sperre nicht erworben.
- Der Ausdruck m.try_lock_shared() hat folgende Eigenschaften:
- Verhält sich als atomare Operation.
- Versucht, den gemeinsamen Besitz des Mutex für den aufrufenden Thread zu erlangen, ohne zu blockieren. Wenn der Besitz nicht erlangt wird, kehrt die Funktion sofort zurück. Die Funktion darf fehlschlagen und zurückkehren, auch wenn der Mutex derzeit nicht von Threads in irgendeinem Modus besessen wird.
- Wenn
try_lock_shared()erfolgreich ist, synchronisieren sich vorherigeunlock()-Operationen auf demselben Objekt mit dieser Operation (entspricht std::memory_order Acquire-Release). - Das Verhalten ist undefiniert, wenn der aufrufende Thread den Mutex bereits in irgendeinem Modus besitzt.
- Der Ausdruck m.unlock_shared() hat folgende Eigenschaften:
- Verhält sich als atomare Operation.
- Gibt den Besitz des Mutex durch den aufrufenden Thread frei und synchronisiert sich mit nachfolgenden erfolgreichen Sperroperationen auf demselben Objekt.
- Das Verhalten ist undefiniert, wenn der aufrufende Thread den Mutex nicht besitzt.
- Alle Sperr- und Entsperroperationen auf einem einzelnen Mutex erfolgen in einer einzigen totalen Ordnung.
[bearbeiten] Standardbibliothek
Die folgenden Standardbibliothekstypen erfüllen die Anforderungen an SharedMutex:
| (C++17) |
bietet gemeinsame Gegenseitiger-Ausschluss-Funktionen (Klasse) |
| (C++14) |
bietet gemeinsame Gegenseitiger-Ausschluss-Funktionen und implementiert ein Sperren mit Timeout (Klasse) |
