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
- C++ working draft — Concurrency support library [thread]
- C++ working draft — Class shared_mutex [thread.sharedmutex.class]
- C++ working draft — Shared mutex types [thread.sharedmutex.requirements]
- C++ working draft — Class template shared_lock [thread.lock.shared]
- C++ working draft — Class template unique_lock [thread.lock.unique]