KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

std::shared_lock — gedeeld lockbezit beheren

std::shared_lock uit <shared_mutex> beheert gedeeld lockbezit met RAII. Meerdere threads kunnen er gelijktijdig mee lezen, maar het biedt niet het exclusieve bezit dat nodig is om gedeelde gegevens te wijzigen.

Versie: C++23; repository compiler flag, production runtime not attested

Syntax

#include <mutex>
#include <shared_mutex>

// Acquire shared ownership immediately:
std::shared_lock<Mutex> guard(m);

// Alternatively, defer acquisition:
// std::shared_lock<Mutex> guard(m, std::defer_lock);

std::shared_lock<Mutex> beheert gedeeld bezit van een lock; het is niet de mutex zelf. Mutex moet voldoen aan de vereisten van Cpp17SharedLockable. Het object kan worden verplaatst, maar niet worden gekopieerd. De bijbehorende mutex moet gedurende de volledige resterende levensduur van de guard bestaan, ook wanneer de guard de lock niet bezit.

Constructie met alleen een mutex roept lock_shared() aan en kan blokkeren. De destructor roept unlock_shared() aan als de guard de lock bezit. std::defer_lock stelt het verkrijgen uit, std::try_to_lock probeert de lock zonder wachten te verkrijgen en std::adopt_lock vereist dat de huidige thread al gedeeld bezit heeft. Gebruik owns_lock() of de omzetting naar bool om het resultaat van een verkrijgingspoging te controleren.

Bij std::shared_mutex kunnen meerdere threads tegelijkertijd gedeeld bezit hebben; exclusief bezit kan daar niet mee samengaan. Volg een consequent protocol: lezen met std::shared_lock, schrijven met een exclusieve lock zoals std::unique_lock. Gedeeld bezit dwingt geen onveranderlijkheid af en beschermt op zichzelf niet tegen gelijktijdige schrijfacties van lezers.

unlock() geeft een bezeten lock vrij, terwijl release() de mutex alleen loskoppelt van de guard — de mutex wordt niet ontgrendeld. Getimede bewerkingen vereisen een mutex die aan Cpp17SharedTimedLockable voldoet; std::shared_mutex volstaat niet. Het voorbeeld gebruikt bewust één thread: het schrijven is klaar voordat het lezen begint, en beide scopes laten automatische vrijgave van de lock zien.

Voorbeelden

#include <iostream>
#include <mutex>
#include <shared_mutex>

int main() {
    std::shared_mutex mutex;
    int value = 0;
    {
        std::unique_lock<std::shared_mutex> writer(mutex);
        value = 42;
    }
    {
        std::shared_lock<std::shared_mutex> reader(mutex);
        std::cout << std::boolalpha
                  << reader.owns_lock() << ' ' << value << '\n';
    }
}

Resultaat

true 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