std::unique_lock
| Definiert in Header <mutex> |
||
| template< class Mutex > class unique_lock; |
(seit C++11) | |
Die Klasse unique_lock ist ein universeller Mutex-Besitz-Wrapper, der verzögertes Sperren, zeitlich begrenzte Sperrversuche, rekursive Sperren, die Übertragung von Sperrbesitz und die Verwendung mit Bedingungsvariablen ermöglicht.
Die Klasse unique_lock ist verschiebbar, aber nicht kopierbar -- sie erfüllt die Anforderungen von MoveConstructible und MoveAssignable, aber nicht von CopyConstructible oder CopyAssignable.
Die Klasse unique_lock erfüllt die BasicLockable-Anforderungen. Wenn Mutex die Lockable-Anforderungen erfüllt, erfüllt unique_lock auch die Lockable-Anforderungen (z.B. kann sie in std::lock verwendet werden); wenn Mutex die TimedLockable-Anforderungen erfüllt, erfüllt unique_lock auch die TimedLockable-Anforderungen.
Inhalt |
[edit] Template-Parameter
| Mutex | - | der Typ des zu sperrenden Mutex. Der Typ muss die BasicLockable-Anforderungen erfüllen |
[edit] Verschachtelte Typen
| Typ | Definition |
mutex_type
|
Mutex
|
[edit] Memberfunktionen
konstruiert einen unique_lock, der optional den übergebenen Mutex sperrt (d.h. den Besitz übernimmt)(public member function) | |
| entsperrt den zugehörigen Mutex (d.h. gibt den Besitz frei), falls vorhanden (public member function) | |
| entsperrt den zugehörigen Mutex (d.h. gibt den Besitz frei), falls vorhanden, und erwirbt den Besitz eines anderen (public member function) | |
Sperren | |
| sperrt den zugehörigen Mutex (d.h. übernimmt den Besitz) (public member function) | |
| versucht, den zugehörigen Mutex ohne Blockieren zu sperren (d.h. den Besitz zu übernehmen) (public member function) | |
| versucht, den zugehörigen TimedLockable Mutex zu sperren (d.h. den Besitz zu übernehmen) und kehrt zurück, wenn der Mutex für die angegebene Zeitspanne nicht verfügbar war (public member function) | |
| versucht, den zugehörigen TimedLockable Mutex zu sperren (d.h. den Besitz zu übernehmen) und kehrt zurück, wenn der Mutex bis zum Erreichen des angegebenen Zeitpunkts nicht verfügbar war (public member function) | |
| entsperrt den zugehörigen Mutex (d.h. gibt den Besitz frei) (public member function) | |
Modifizierer | |
| tauscht den Zustand mit einem anderen std::unique_lock (public member function) | |
| trennt den zugehörigen Mutex, ohne ihn zu entsperren (d.h. den Besitz aufzugeben) (public member function) | |
Observer | |
| gibt einen Zeiger auf den zugehörigen Mutex zurück (public member function) | |
| prüft, ob die Sperre den zugehörigen Mutex besitzt (d.h. gesperrt hat) (public member function) | |
| prüft, ob die Sperre den zugehörigen Mutex besitzt (d.h. gesperrt hat) (public member function) | |
[edit] Nicht-Member-Funktionen
| (C++11) |
spezialisiert den Algorithmus std::swap (Funktionsvorlage) |
[edit] Beispiel
#include <iostream> #include <mutex> #include <thread> struct Box { explicit Box(int num) : num_things{num} {} int num_things; std::mutex m; }; void transfer(Box& from, Box& to, int num) { // don't actually take the locks yet std::unique_lock lock1{from.m, std::defer_lock}; std::unique_lock lock2{to.m, std::defer_lock}; // lock both unique_locks without deadlock std::lock(lock1, lock2); from.num_things -= num; to.num_things += num; // “from.m” and “to.m” mutexes unlocked in unique_lock dtors } int main() { Box acc1{100}; Box acc2{50}; std::thread t1{transfer, std::ref(acc1), std::ref(acc2), 10}; std::thread t2{transfer, std::ref(acc2), std::ref(acc1), 5}; t1.join(); t2.join(); std::cout << "acc1: " << acc1.num_things << "\n" "acc2: " << acc2.num_things << '\n'; }
Ausgabe
acc1: 95 acc2: 55
[edit] Fehlerberichte
Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.
| DR | angewendet auf | Verhalten wie veröffentlicht | Korrigiertes Verhalten |
|---|---|---|---|
| LWG 2981 | C++17 | redundanter Deduction Guide aus unique_lock<Mutex> wurde bereitgestellt |
entfernt |
[edit] Siehe auch
| (C++11) |
sperrt angegebene Mutexe, blockiert, wenn einer nicht verfügbar ist (Funktionsvorlage) |
| (C++11) |
implementiert einen streng bereichsbezogenen Mutex-Besitz-Wrapper (Klassen-Template) |
| (C++17) |
todesfallsichere RAII-Hülle für mehrere Mutexe (Klassen-Template) |
| (C++11) |
bietet grundlegende Gegenseitiger-Ausschluss-Funktionen (Klasse) |
