Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / C++

std::shared_lock — správa zdieľaného vlastníctva zámku

std::shared_lock z <shared_mutex> spravuje zdieľané vlastníctvo zámku pomocou RAII. Umožňuje súčasné čítanie viacerými vláknami, ale neposkytuje výhradné vlastníctvo potrebné na zmenu zdieľaných údajov.

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

Syntax

#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 zdieľané vlastníctvo zámku; nie je to samotný mutex. Mutex musí spĺňať požiadavky Cpp17SharedLockable. Objekt možno presúvať, ale nemožno ho kopírovať. Pridružený mutex musí existovať počas celého zostávajúceho času života strážcu, aj keď strážca zámok nevlastní.

Konštrukcia iba s mutexom volá lock_shared() a môže blokovať. Deštruktor volá unlock_shared(), ak strážca zámok vlastní. std::defer_lock odloží získanie zámku, std::try_to_lock sa ho pokúsi získať bez čakania a std::adopt_lock vyžaduje, aby aktuálne vlákno už malo zdieľané vlastníctvo. Výsledok pokusu o získanie zámku možno skontrolovať pomocou owns_lock() alebo konverziou na bool.

Pri std::shared_mutex môže zdieľané vlastníctvo zámku mať súčasne viacero vlákien; výhradné vlastníctvo s ním nemôže existovať súčasne. Dodržiavajte jednotný protokol: čítanie pod std::shared_lock, zápisy pod výhradným zámkom, napríklad std::unique_lock. Zdieľané vlastníctvo nezaručuje nemennosť údajov a samo osebe nechráni pred súbežnými zápismi čitateľov.

unlock() uvoľní vlastnený zámok, zatiaľ čo release() iba odpojí mutex od strážcu — neodomkne ho. Časované operácie vyžadujú mutex spĺňajúci Cpp17SharedTimedLockable; std::shared_mutex nestačí. Príklad zámerne používa jedno vlákno: zápis sa skončí pred čítaním a oba bloky ukazujú automatické uvoľnenie zámku.

Prí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ýsledok

true 42

Zobrazený kód a uvedený výsledok boli overené v izolovanom prostredí metódou zaznamenanou v dôkaze o overení tejto presnej verzie.

Zdroje