WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

std::shared_lock — gemeinsamen Sperrbesitz verwalten

std::shared_lock aus <shared_mutex> verwaltet den gemeinsamen Besitz einer Sperre mithilfe von RAII. Er ermöglicht mehreren Threads gleichzeitige Lesezugriffe, bietet aber nicht den exklusiven Besitz, der zum Ändern gemeinsamer Daten erforderlich ist.

Version: 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> verwaltet den gemeinsamen Besitz einer Sperre; es ist nicht selbst der Mutex. Mutex muss die Anforderungen von Cpp17SharedLockable erfüllen. Das Objekt ist verschiebbar, aber nicht kopierbar. Der zugehörige Mutex muss während der gesamten verbleibenden Lebensdauer des Guards existieren, auch wenn der Guard die Sperre nicht besitzt.

Die Konstruktion nur mit einem Mutex ruft lock_shared() auf und kann blockieren. Der Destruktor ruft unlock_shared() auf, wenn der Guard die Sperre besitzt. std::defer_lock verschiebt den Erwerb, std::try_to_lock versucht ihn ohne zu warten, und std::adopt_lock setzt voraus, dass der aktuelle Thread den gemeinsamen Besitz bereits hat. Mit owns_lock() oder der Umwandlung in bool lässt sich das Ergebnis eines Erwerbsversuchs prüfen.

Bei std::shared_mutex können mehrere Threads gleichzeitig gemeinsamen Besitz haben; exklusiver Besitz kann nicht gleichzeitig bestehen. Verwende ein einheitliches Protokoll: Lesezugriffe mit std::shared_lock, Schreibzugriffe mit einer exklusiven Sperre wie std::unique_lock. Gemeinsamer Besitz erzwingt keine Unveränderlichkeit und schützt nicht selbst vor gleichzeitigen Schreibzugriffen durch Leser.

unlock() gibt eine besessene Sperre frei, während release() den Mutex lediglich vom Guard trennt – es entsperrt ihn nicht. Zeitgesteuerte Operationen erfordern einen Mutex, der Cpp17SharedTimedLockable erfüllt; std::shared_mutex reicht dafür nicht aus. Das Beispiel verwendet bewusst einen einzelnen Thread: Das Schreiben ist vor dem Lesen abgeschlossen, und beide Gültigkeitsbereiche veranschaulichen die automatische Freigabe der Sperre.

Beispiele

#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';
    }
}

Ergebnis

true 42

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen