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

CKTIS / C++

std::shared_mutex — sdílené a výhradní zamykání

std::shared_mutex umožňuje, aby zámek současně vlastnilo více vláken ve sdíleném režimu, nebo aby jej výhradně vlastnilo jedno vlákno. Pro čtení používejte std::shared_lock a pro zápis std::unique_lock; při každém přístupu k chráněným datům dodržujte stejný protokol.

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

Syntaxe

#include <shared_mutex>
#include <mutex>

std::shared_mutex m;
// In separate scopes:
{ std::shared_lock<std::shared_mutex> read_lock(m); }
{ std::unique_lock<std::shared_mutex> write_lock(m); }

std::shared_mutex deklarovaný v <shared_mutex> je nerekurzivní mutex. Sdílený režim povoluje současně více vlastníků; výhradní režim vylučuje všechny ostatní vlastníky. Obvyklý protokol spočívá ve čtení se sdíleným vlastnictvím a v úpravách s výhradním vlastnictvím. Mutex sám přístup k proměnným nekontroluje: váš kód musí tento protokol důsledně dodržovat.

lock() a unlock() spravují výhradní vlastnictví, zatímco lock_shared() a unlock_shared() spravují sdílené vlastnictví. Blokující operace čekají, dokud nebude možné vlastnictví získat. try_lock() a try_lock_shared() se o získání pokoušejí bez čekání a vracejí bool; mohou selhat i bez skutečné překážky, takže false nedokazuje, že mutex vlastní jiné vlákno.

Místo ručního odemykání dávejte přednost RAII: pro čtenáře použijte std::shared_lock<std::shared_mutex> z <shared_mutex> a pro zapisující std::unique_lock<std::shared_mutex> z <mutex>. Tyto objekty uvolní vlastněný zámek při opuštění svého rozsahu, a to i během propagace výjimky. Sdílené vlastnictví neposkytuje výhradní přístup potřebný k běžným úpravám sdílených dat.

Nepokoušejte se znovu získat žádný druh vlastnictví ve vlákně, které už vlastní tentýž mutex: chování je nedefinované. Patří sem i pokus získat výhradní vlastnictví bez uvolnění sdíleného. Odemknutí a opětovné zamknutí není atomická změna režimu — mezitím se mohou data změnit. Neničte vlastněný mutex a nedovolte, aby vlákno skončilo, dokud mutex stále vlastní.

Příklad odděluje zápis od čtení pomocí join() a každý přístup k value chrání příslušným zámkem. Čtenáři mohou běžet souběžně, ale nemusí; výsledky ukládají do samostatných proměnných. Výpis po obou voláních join() vytvoří deterministický výsledek 42 42.

Příklady

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

int main() {
    std::shared_mutex mutex;
    int value = 0;

    std::thread writer([&] {
        std::unique_lock<std::shared_mutex> lock(mutex);
        value = 42;
    });
    writer.join();

    int first = 0;
    int second = 0;
    std::thread reader1([&] {
        std::shared_lock<std::shared_mutex> lock(mutex);
        first = value;
    });
    std::thread reader2([&] {
        std::shared_lock<std::shared_mutex> lock(mutex);
        second = value;
    });
    reader1.join();
    reader2.join();

    std::cout << first << ' ' << second << '\n';
}

Výsledek

42 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