CKTIS / C++
std::shared_mutex — gedeeld en exclusief vergrendelen
Met std::shared_mutex kunnen meerdere threads tegelijk gedeeld eigenaarschap hebben, of kan één thread exclusief eigenaarschap hebben. Gebruik std::shared_lock om te lezen en std::unique_lock om te schrijven, en volg bij elke toegang tot de beschermde gegevens hetzelfde protocol.
Versie: 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, gedeclareerd in <shared_mutex>, is een niet-recursieve mutex. In de gedeelde modus zijn meerdere eigenaars tegelijk toegestaan; in de exclusieve modus worden alle andere eigenaars uitgesloten. Het gebruikelijke protocol is lezen met gedeeld eigenaarschap en wijzigen met exclusief eigenaarschap. De mutex controleert zelf geen toegang tot variabelen: uw code moet dit protocol consequent volgen.
lock() en unlock() beheren exclusief eigenaarschap, terwijl lock_shared() en unlock_shared() gedeeld eigenaarschap beheren. De blokkerende bewerkingen wachten tot eigenaarschap kan worden verkregen. try_lock() en try_lock_shared() proberen dit zonder te wachten en geven bool terug; ze kunnen spurieus mislukken. false bewijst dus niet dat een andere thread de mutex bezit.
Gebruik bij voorkeur RAII in plaats van handmatig ontgrendelen: std::shared_lock<std::shared_mutex> uit <shared_mutex> voor lezers en std::unique_lock<std::shared_mutex> uit <mutex> voor schrijvers. Deze objecten geven een vergrendeling die ze bezitten vrij wanneer hun bereik eindigt, ook tijdens het doorgeven van een uitzondering. Gedeeld eigenaarschap biedt niet de exclusiviteit die nodig is voor gewone wijzigingen aan gedeelde gegevens.
Probeer niet opnieuw een van beide soorten eigenaarschap te verkrijgen in een thread die dezelfde mutex al bezit: het gedrag is ongedefinieerd. Dit geldt ook voor een poging exclusief eigenaarschap te verkrijgen zonder gedeeld eigenaarschap vrij te geven. Ontgrendelen en opnieuw vergrendelen is geen atomische moduswijziging: gegevens kunnen intussen veranderen. Vernietig geen mutex die in gebruik is en laat een thread niet eindigen zolang die de mutex nog bezit.
Het voorbeeld scheidt schrijven van lezen met join() en beschermt elke toegang tot value met de juiste vergrendeling. De lezers kunnen gelijktijdig worden uitgevoerd, maar dat hoeft niet; ze slaan resultaten op in afzonderlijke variabelen. Afdrukken na beide aanroepen van join() levert het deterministische resultaat 42 42 op.
Voorbeelden
#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';
}
Resultaat
42 42
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.
Bronnen
- 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]