CKTIS / C++
std::unique_lock — flexibel beheer van mutexvergrendelingen
std::unique_lock is een verplaatsbaar maar niet-kopieerbaar RAII-object uit <mutex> dat het bezit van een mutexvergrendeling beheert. Het ondersteunt uitgesteld vergrendelen, ontgrendelen vóór het verlaten van de scope en opnieuw vergrendelen. De destructor ontgrendelt de mutex alleen als het object de vergrendeling nog bezit.
Versie: 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> uit <mutex> beheert het bezit van de vergrendeling, niet de levensduur van de mutex. Het gebruikt RAII: als het object de vergrendeling bezit, roept de destructor unlock() aan op de mutex, ook wanneer een uitzondering ervoor zorgt dat de scope wordt verlaten. De mutex moet geldig blijven zolang het object eraan gekoppeld is. Het object kan worden verplaatst, maar niet gekopieerd.
Constructie met alleen een mutex roept diens lock() aan. De tag std::defer_lock legt een koppeling zonder te vergrendelen; std::try_to_lock doet een niet-blokkerende poging waarvan u het resultaat kunt controleren met owns_lock() of door omzetting naar bool. std::adopt_lock vereist dat de huidige thread al een exclusieve vergrendeling op de mutex bezit; het is geen manier om die vergrendeling te verkrijgen.
Met lock() en unlock() kunt u de toestand vóór het verlaten van de scope wijzigen. Roep lock() niet aan wanneer het object de vergrendeling al bezit, en unlock() niet wanneer het die niet bezit. Mutex moet voldoen aan de eisen van BasicLockable; try-lock-bewerkingen vereisen daarnaast Lockable, terwijl try_lock_for() en try_lock_until() TimedLockable vereisen. Het gebruik van std::unique_lock voegt op zichzelf geen ondersteuning voor time-outs toe aan een mutex.
Verwar release() niet met unlock(): release() geeft de mutexaanwijzer terug en verwijdert de koppeling, maar ontgrendelt de mutex niet. De verantwoordelijkheid voor eventueel noodzakelijk ontgrendelen gaat over op de aanroepende code. Het voorbeeld toont uitgesteld vergrendelen, expliciet ontgrendelen en opnieuw vergrendelen, waarna de destructor de vergrendeling vrijgeeft. Eén thread zorgt voor deterministische uitvoer; het voorbeeld demonstreert geen thread-contentie.
Voorbeelden
#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';
}
Resultaat
false true 1 false 1
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.