CKTIS / C++
std::unique_lock — flexible Verwaltung von Mutex-Sperren
std::unique_lock ist ein verschiebbares, aber nicht kopierbares RAII-Objekt aus <mutex>, das den Besitz einer Mutex-Sperre verwaltet. Es unterstützt verzögertes Sperren, Entsperren vor dem Verlassen des Gültigkeitsbereichs und erneutes Sperren. Sein Destruktor entsperrt den Mutex nur, wenn das Objekt die Sperre noch besitzt.
Version: C++23; repository compiler flag, production runtime not attested
Syntax
#include <mutex>
std::unique_lock<Mutex> lock(mutex);
std::unique_lock<Mutex> lock(mutex, std::defer_lock);std::unique_lock<Mutex> aus <mutex> verwaltet den Besitz der Sperre, nicht die Lebensdauer des Mutex. Es verwendet RAII: Besitzt das Objekt die Sperre, ruft sein Destruktor unlock() für den Mutex auf, auch wenn eine Ausnahme zum Verlassen des Gültigkeitsbereichs führt. Der Mutex muss so lange gültig bleiben, wie das Objekt mit ihm verbunden ist. Das Objekt kann verschoben, aber nicht kopiert werden.
Die Konstruktion nur mit einem Mutex ruft dessen lock() auf. Das Tag std::defer_lock stellt eine Verbindung her, ohne zu sperren; std::try_to_lock unternimmt einen nicht blockierenden Versuch, dessen Ergebnis Sie mit owns_lock() oder durch Umwandlung in bool prüfen können. std::adopt_lock setzt voraus, dass der aktuelle Thread bereits eine exklusive Sperre des Mutex besitzt; es ist keine Möglichkeit, diese Sperre zu erwerben.
Mit lock() und unlock() können Sie den Zustand vor dem Verlassen des Gültigkeitsbereichs ändern. Rufen Sie lock() nicht auf, wenn das Objekt die Sperre bereits besitzt, und unlock() nicht, wenn es sie nicht besitzt. Mutex muss die Anforderungen von BasicLockable erfüllen; Try-Lock-Operationen erfordern zusätzlich Lockable, während try_lock_for() und try_lock_until() TimedLockable voraussetzen. Die Verwendung von std::unique_lock fügt einem Mutex nicht von selbst Zeitlimit-Unterstützung hinzu.
Verwechseln Sie release() nicht mit unlock(): release() gibt den Mutex-Zeiger zurück und löst die Verbindung, entsperrt den Mutex aber nicht. Die Verantwortung für ein gegebenenfalls erforderliches Entsperren geht auf den aufrufenden Code über. Das Beispiel zeigt verzögertes Sperren, explizites Entsperren und erneutes Sperren; anschließend gibt der Destruktor die Sperre frei. Ein einzelner Thread sorgt für eine deterministische Ausgabe; das Beispiel demonstriert keinen Thread-Konflikt.
Beispiele
#include <iostream>
#include <mutex>
int main() {
std::mutex mutex;
int value = 0;
{
std::unique_lock<std::mutex> lock(mutex, std::defer_lock);
std::cout << std::boolalpha << lock.owns_lock() << '\n';
lock.lock();
++value;
std::cout << lock.owns_lock() << ' ' << value << '\n';
lock.unlock();
std::cout << lock.owns_lock() << '\n';
lock.lock();
}
std::cout << value << '\n';
}
Ergebnis
false true 1 false 1
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.