Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C++

std::shared_lock — správa sdíleného vlastnictví zámku

std::shared_lock z <shared_mutex> spravuje sdílené vlastnictví zámku pomocí RAII. Umožňuje současné čtení více vlákny, ale neposkytuje výhradní vlastnictví potřebné ke změně sdílených dat.

Verze: C++23; repository compiler flag, production runtime not attested

Syntaxe

#include <mutex>
#include <shared_mutex>

// Acquire shared ownership immediately:
std::shared_lock<Mutex> guard(m);

// Alternatively, defer acquisition:
// std::shared_lock<Mutex> guard(m, std::defer_lock);

std::shared_lock<Mutex> spravuje sdílené vlastnictví zámku; není to samotný mutex. Mutex musí splňovat požadavky Cpp17SharedLockable. Objekt lze přesouvat, ale nelze jej kopírovat. Přidružený mutex musí existovat po celou zbývající dobu života strážce, i když strážce zámek nevlastní.

Konstrukce pouze s mutexem volá lock_shared() a může blokovat. Destruktor volá unlock_shared(), pokud strážce zámek vlastní. std::defer_lock odloží získání zámku, std::try_to_lock se jej pokusí získat bez čekání a std::adopt_lock vyžaduje, aby aktuální vlákno sdílené vlastnictví už mělo. Výsledek pokusu o získání zámku lze ověřit pomocí owns_lock() nebo převodem na bool.

U std::shared_mutex může sdílené vlastnictví zámku mít současně více vláken; výhradní vlastnictví s ním nemůže existovat souběžně. Dodržujte jednotný postup: čtení pod std::shared_lock, zápisy pod výhradním zámkem, například std::unique_lock. Sdílené vlastnictví nezajišťuje neměnnost dat a samo o sobě nechrání před souběžnými zápisy čtenářů.

unlock() uvolní vlastněný zámek, zatímco release() pouze odpojí mutex od strážce — neodemkne jej. Časované operace vyžadují mutex splňující Cpp17SharedTimedLockable; std::shared_mutex nestačí. Příklad záměrně používá jedno vlákno: zápis skončí před čtením a oba bloky ukazují automatické uvolnění zámku.

Příklady

#include <iostream>
#include <mutex>
#include <shared_mutex>

int main() {
    std::shared_mutex mutex;
    int value = 0;
    {
        std::unique_lock<std::shared_mutex> writer(mutex);
        value = 42;
    }
    {
        std::shared_lock<std::shared_mutex> reader(mutex);
        std::cout << std::boolalpha
                  << reader.owns_lock() << ' ' << value << '\n';
    }
}

Výsledek

true 42

Zobrazený kód a uvedený výsledek byly ověřeny v izolovaném prostředí metodou zaznamenanou v dokladu o ověření této přesné verze.

Zdroje