CKTIS / C++
std::shared_mutex — blokada współdzielona i wyłączna
std::shared_mutex pozwala wielu wątkom jednocześnie posiadać blokadę współdzieloną albo jednemu wątkowi posiadać blokadę wyłączną. Używaj std::shared_lock do odczytu i std::unique_lock do zapisu, przestrzegając tego samego protokołu przy każdym dostępie do chronionych danych.
Wersja: C++23; repository compiler flag, production runtime not attested
Składnia
#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 z nagłówka <shared_mutex> jest muteksem nierekurencyjnym. Tryb współdzielony dopuszcza wielu właścicieli naraz; tryb wyłączny wyklucza wszystkich pozostałych właścicieli. Typowy protokół to odczyty pod blokadą współdzieloną i modyfikacje pod wyłączną. Sam muteks nie kontroluje dostępu do zmiennych: kod musi konsekwentnie stosować ten protokół.
lock() i unlock() obsługują własność wyłączną, a lock_shared() i unlock_shared() — współdzieloną. Metody blokujące czekają na możliwość uzyskania własności. try_lock() i try_lock_shared() próbują bez czekania i zwracają bool; mogą zawieść pozornie, więc false nie dowodzi, że inny wątek posiada blokadę.
Zamiast ręcznie zwalniać blokadę, używaj RAII: std::shared_lock<std::shared_mutex> z <shared_mutex> dla czytelników oraz std::unique_lock<std::shared_mutex> z <mutex> dla pisarzy. Te obiekty zwalniają posiadaną blokadę przy opuszczeniu zakresu, także podczas propagacji wyjątku. Blokada współdzielona nie zapewnia wyłączności potrzebnej do zwykłej modyfikacji wspólnych danych.
Nie próbuj ponownie uzyskać żadnego rodzaju własności tego samego muteksu w wątku, który już go posiada: zachowanie jest niezdefiniowane. Dotyczy to także próby uzyskania własności wyłącznej bez zwolnienia współdzielonej. Zwolnienie i ponowne zablokowanie nie jest atomową zmianą trybu — w międzyczasie dane mogą się zmienić. Nie niszcz zajętego muteksu ani nie kończ wątku, który nadal go posiada.
Przykład oddziela zapis od odczytów przez join(), a każdy dostęp do value chroni odpowiednią blokadą. Czytelnicy mogą działać równolegle, ale nie muszą; zapisują wyniki do osobnych zmiennych. Wypisywanie po obu join() daje deterministyczny wynik 42 42.
Przykłady
#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';
}
Wynik
42 42
Wyświetlony kod i zadeklarowany wynik zweryfikowano w odizolowanym środowisku metodą zapisaną w dowodzie weryfikacji tej dokładnej wersji.
Źródła
- 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]