WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

std::scoped_lock — an den Gültigkeitsbereich gebundener Besitz von Sperren

std::scoped_lock besitzt Mutex-Sperren für die Lebensdauer des Objekts. Der Konstruktor sperrt die angegebenen Mutexes, der Destruktor entsperrt sie. Bei mehreren Mutexes verwendet std::scoped_lock std::lock, um Deadlocks beim gemeinsamen Sperren zu vermeiden.

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

Syntax

#include <mutex>

{
    std::scoped_lock guard(m1, m2);
}

{
    std::lock(m1, m2);
    std::scoped_lock adopted(std::adopt_lock, m1, m2);
}

std::scoped_lock aus <mutex> ist ein RAII-Guard: Er bindet den Besitz der Sperren an die Lebensdauer eines benannten Objekts. Sein Destruktor ruft für jeden Mutex unlock() auf, auch wenn eine Ausnahme den Gültigkeitsbereich verlässt. Der Guard kann weder kopiert noch verschoben werden; die Mutexes müssen während seiner gesamten Lebensdauer bestehen.

Der gewöhnliche Konstruktor sperrt bei null Mutexes nichts, ruft bei einem Mutex lock() auf und verwendet bei mehreren std::lock. Ein einzelner Mutex-Typ muss Cpp17BasicLockable erfüllen; mehrere Mutex-Typen müssen Cpp17Lockable erfüllen. Der Algorithmus vermeidet Deadlocks beim gemeinsamen Erwerben dieser Sperren, verhindert aber nicht jeden Deadlock in einem Programm. Wirft das Sperren über std::lock eine Ausnahme, gibt der Aufruf die von ihm erworbenen Sperren frei, bevor er die Ausnahme weiterleitet.

Die Überladung mit std::adopt_lock sperrt die Mutexes nicht: Sie übernimmt die Verantwortung dafür, sie zu entsperren. Der aufrufende Thread muss bereits eine exklusive Sperre auf jedem Mutex besitzen. Verwende den gewöhnlichen Konstruktor nicht, um einen bereits besessenen std::mutex erneut zu sperren. Gib dem Guard einen Namen: Das temporäre Objekt in std::scoped_lock{m1, m2}; wird am Ende dieser Anweisung zerstört.

Das Beispiel aktualisiert zwei Werte, während beide Sperren gehalten werden, und gibt nach ihrer Freigabe 7 23 aus. Es verwendet absichtlich nur einen Thread, damit die Ausgabe deterministisch ist; Thread-Konkurrenz wird nicht demonstriert. In einem nebenläufigen Programm müssen alle Zugriffe auf dieselben geschützten Daten einem einheitlichen Synchronisierungsprotokoll folgen.

Beispiele

#include <iostream>
#include <mutex>

int main() {
    std::mutex left_mutex;
    std::mutex right_mutex;
    int left = 10;
    int right = 20;

    {
        std::scoped_lock guard(left_mutex, right_mutex);
        left -= 3;
        right += 3;
    }

    std::cout << left << ' ' << right << '\n';
}

Ergebnis

7 23

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