CKTIS / C++
std::shared_mutex — споделено и изключително заключване
std::shared_mutex позволява няколко нишки едновременно да притежават споделено заключване или една нишка да притежава изключително заключване. Използвайте std::shared_lock за четене и std::unique_lock за запис, като следвате един и същ протокол при всеки достъп до защитените данни.
Версия: C++23; repository compiler flag, production runtime not attested
Синтаксис
#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, деклариран в <shared_mutex>, е нерекурсивен мютекс. Споделеният режим допуска няколко притежатели едновременно; изключителният режим изключва всички останали притежатели. Обичайният протокол е четене при споделено притежание и промяна при изключително притежание. Самият мютекс не контролира достъпа до променливите: кодът ви трябва последователно да спазва този протокол.
lock() и unlock() управляват изключителното притежание, а lock_shared() и unlock_shared() — споделеното. Блокиращите операции изчакват, докато притежанието може да бъде придобито. try_lock() и try_lock_shared() се опитват да го придобият без изчакване и връщат bool; възможен е и привиден неуспех, затова false не доказва, че друга нишка притежава мютекса.
Предпочитайте RAII пред ръчното отключване: използвайте std::shared_lock<std::shared_mutex> от <shared_mutex> за четящите нишки и std::unique_lock<std::shared_mutex> от <mutex> за записващите. Тези обекти освобождават притежаваното заключване при излизане от обхвата им, включително при разпространяване на изключение. Споделеното притежание не осигурява изключителността, необходима за обичайна промяна на споделени данни.
Не се опитвайте отново да придобиете който и да е вид притежание в нишка, която вече притежава същия мютекс: поведението е неопределено. Това включва опит за придобиване на изключително притежание, без първо да освободите споделеното. Отключването и повторното заключване не са атомарна смяна на режима — междувременно данните могат да се променят. Не унищожавайте притежаван мютекс и не допускайте нишка да приключи, докато все още го притежава.
Примерът отделя записа от четенето чрез join() и защитава всеки достъп до value с подходящото заключване. Четещите нишки могат да се изпълняват едновременно, но това не е задължително; те записват резултатите в отделни променливи. Извеждането след двете извиквания на join() дава детерминирания резултат 42 42.
Примери
#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';
}
Резултат
42 42
Показаният код и заявеният резултат са проверени в изолирана среда по метода, записан в доказателството за проверка на тази точна версия.
Източници
- 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]