KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

std::scoped_lock — lockbezit gekoppeld aan de scope

std::scoped_lock bezit mutexlocks gedurende de levensduur van het object. De constructor vergrendelt de opgegeven mutexen en de destructor ontgrendelt ze. Bij meerdere mutexen gebruikt std::scoped_lock std::lock om deadlock bij gezamenlijke verwerving te voorkomen.

Versie: 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 uit <mutex> is een RAII-guard: hij koppelt het bezit van locks aan de levensduur van een benoemd object. De destructor roept voor elke mutex unlock() aan, ook wanneer een exception het verlaten van de scope veroorzaakt. De guard kan niet worden gekopieerd of verplaatst; de mutexen moeten gedurende de hele levensduur van de guard bestaan.

De gewone constructor vergrendelt niets bij nul mutexen, roept lock() aan bij één mutex en gebruikt std::lock bij meerdere mutexen. Eén mutextype moet voldoen aan Cpp17BasicLockable; meerdere mutextypen moeten voldoen aan Cpp17Lockable. Het algoritme voorkomt deadlock bij het gezamenlijk verkrijgen van die locks, maar voorkomt niet elke deadlock in een programma. Als het verkrijgen via std::lock een exception werpt, geeft die aanroep de locks die hij heeft verkregen vrij voordat de exception wordt doorgegeven.

De overload met std::adopt_lock vergrendelt de mutexen niet: hij neemt de verantwoordelijkheid voor het ontgrendelen ervan over. De aanroepende thread moet al een exclusieve lock op elk van die mutexen hebben. Gebruik de gewone constructor niet om een al bezeten std::mutex opnieuw te vergrendelen. Geef de guard een naam: het tijdelijke object in std::scoped_lock{m1, m2}; wordt aan het einde van die instructie vernietigd.

Het voorbeeld werkt twee waarden bij terwijl beide locks worden vastgehouden en drukt 7 23 af nadat ze zijn vrijgegeven. Het gebruikt bewust één thread voor een deterministische uitvoer; threadcontentie wordt niet getoond. In een concurrent programma moeten alle toegangen tot dezelfde beschermde gegevens een consistent synchronisatieprotocol volgen.

Voorbeelden

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

Resultaat

7 23

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