CKTIS / C++
std::shared_mutex — zdieľané a výhradné zamykanie
std::shared_mutex umožňuje, aby zámok súčasne vlastnilo viacero vlákien v zdieľanom režime, alebo aby ho výhradne vlastnilo jedno vlákno. Na čítanie používajte std::shared_lock a na zápis std::unique_lock; pri každom prístupe k chráneným údajom dodržiavajte rovnaký protokol.
Verzia: C++23; repository compiler flag, production runtime not attested
Syntax
#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 nerekurzívny mutex. Zdieľaný režim povoľuje súčasne viacero vlastníkov; výhradný režim vylučuje všetkých ostatných vlastníkov. Obvyklý protokol spočíva v čítaní so zdieľaným vlastníctvom a v úpravách s výhradným vlastníctvom. Mutex sám prístup k premenným nekontroluje: váš kód musí tento protokol dôsledne dodržiavať.
lock() a unlock() spravujú výhradné vlastníctvo, zatiaľ čo lock_shared() a unlock_shared() spravujú zdieľané vlastníctvo. Blokujúce operácie čakajú, kým nebude možné vlastníctvo získať. try_lock() a try_lock_shared() sa o získanie pokúšajú bez čakania a vracajú bool; môžu zlyhať aj bez skutočnej prekážky, takže false nedokazuje, že mutex vlastní iné vlákno.
Namiesto ručného odomykania uprednostnite RAII: pre čitateľov použite std::shared_lock<std::shared_mutex> z <shared_mutex> a pre zapisujúcich std::unique_lock<std::shared_mutex> z <mutex>. Tieto objekty uvoľnia vlastnený zámok pri opustení svojho rozsahu, aj počas propagácie výnimky. Zdieľané vlastníctvo neposkytuje výhradný prístup potrebný na bežné úpravy zdieľaných údajov.
Nepokúšajte sa znova získať žiadny druh vlastníctva vo vlákne, ktoré už vlastní ten istý mutex: správanie je nedefinované. Patrí sem aj pokus získať výhradné vlastníctvo bez uvoľnenia zdieľaného. Odomknutie a opätovné zamknutie nie je atómová zmena režimu — medzičasom sa údaje môžu zmeniť. Neničte vlastnený mutex a nedovoľte, aby sa vlákno skončilo, kým mutex stále vlastní.
Príklad oddeľuje zápis od čítania pomocou join() a každý prístup k value chráni príslušným zámkom. Čitatelia môžu bežať súbežne, ale nemusia; výsledky ukladajú do samostatných premenných. Výpis po oboch volaniach join() vytvorí deterministický výsledok 42 42.
Prí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ýsledok
42 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
- 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]