CKTIS / C++
std::recursive_mutex — wiederholtes Sperren durch denselben Thread
std::recursive_mutex ermöglicht es demselben Thread, denselben Mutex mehrfach zu übernehmen. Andere Threads können ihn erst übernehmen, wenn alle Besitzebenen freigegeben wurden. Jede erfolgreiche Übernahme muss separat entsperrt werden.
Version: C++23; repository compiler flag, production runtime not attested
Syntax
#include <mutex>
std::recursive_mutex m;
std::lock_guard<std::recursive_mutex> guard(m);std::recursive_mutex aus <mutex> bietet exklusiven Besitz und erlaubt dem Besitzer, den Mutex wiederholt zu übernehmen. Anders als bei std::mutex kann derselbe Thread erneut lock() oder erfolgreich try_lock() aufrufen, während er den Mutex bereits besitzt. Das bedeutet nicht, dass sich mehrere Threads den Besitz teilen.
Jede erfolgreiche Übernahme erhöht die Verschachtelungsebene und erfordert einen Aufruf von unlock(). Solange der Besitzer nicht alle Ebenen freigegeben hat, blockiert lock() eines anderen Threads, und dessen try_lock() gibt false zurück. Die maximale Anzahl der Ebenen ist nicht festgelegt: Ist sie erreicht, schlägt try_lock() fehl und lock() löst std::system_error aus.
Verwende std::lock_guard<std::recursive_mutex>, damit jede Übernahme beim Verlassen des Gültigkeitsbereichs freigegeben wird, auch wenn dieser durch eine Ausnahme verlassen wird. Der Mutex muss länger leben als seine Guards. Einen Mutex zu zerstören, während er besessen wird, oder einen Thread zu beenden, während er den Mutex noch besitzt, führt zu undefiniertem Verhalten.
Im Beispiel hält increment_twice() die äußere Sperre, und jeder Aufruf von increment() fügt vorübergehend eine weitere Ebene hinzu. Die Guards geben die Ebenen in umgekehrter Reihenfolge frei. Ein Thread genügt, um die wiederholte Übernahme und eine deterministische Ausgabe zu zeigen; das Beispiel testet keine Konkurrenz zwischen Threads. Ein rekursiver Mutex ersetzt keine durchdachte Sperrreihenfolge für mehrere Mutexe.
Beispiele
#include <iostream>
#include <mutex>
class Counter {
std::recursive_mutex mutex_;
int value_ = 0;
public:
void increment() {
std::lock_guard<std::recursive_mutex> guard(mutex_);
++value_;
}
int increment_twice() {
std::lock_guard<std::recursive_mutex> guard(mutex_);
increment();
increment();
return value_;
}
};
int main() {
Counter counter;
std::cout << counter.increment_twice() << '\n';
}
Ergebnis
2
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.