KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

std::mutex — wederzijdse uitsluiting tussen threads

std::mutex uit <mutex> laat telkens maar één thread de vergrendeling bezitten. Het beschermt gedeelde gegevens wanneer alle conflicterende toegang dezelfde vergrendelingsprocedure volgt. std::lock_guard beheert het vrijgeven van de vergrendeling binnen een bereik.

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

Syntax

#include <mutex>
std::mutex m;
std::lock_guard<std::mutex> guard(m);

std::mutex uit <mutex> biedt exclusief, niet-recursief bezit van een vergrendeling. Een kritieke sectie is code die wordt uitgevoerd terwijl die vergrendeling in bezit is. Een mutex beschermt gegevens niet automatisch: alle toegang die mogelijk conflicteert, moet hetzelfde synchronisatieprotocol volgen.

lock() wacht totdat de vergrendeling kan worden verkregen. try_lock() wacht niet en geeft aan of het is gelukt; het kan false retourneren, zelfs als de mutex beschikbaar is. unlock() geeft de vergrendeling vrij en mag alleen door de eigenaar worden aangeroepen. Het vrijgeven synchroniseert met een latere succesvolle verkrijging van dezelfde mutex, waardoor eerdere schrijfbewerkingen zichtbaar worden.

Gebruik bij voorkeur een benoemd object van het type std::lock_guard<std::mutex>: de constructor vergrendelt de mutex en de destructor ontgrendelt deze, ook wanneer een uitzondering het verlaten van het bereik veroorzaakt. De mutex moet langer bestaan dan de guard. Probeer een std::mutex die je al bezit niet opnieuw te verkrijgen; recursie wordt niet ondersteund. De mutex kan niet worden gekopieerd of verplaatst, en het vernietigen van een mutex die in bezit is veroorzaakt ongedefinieerd gedrag.

In het voorbeeld verhogen twee threads counter onder dezelfde vergrendeling. Elke aanroep van join() wacht alleen tot de thread die door het betreffende object wordt vertegenwoordigd, is beëindigd. Voordat de teller wordt gelezen, wacht het voorbeeld met first.join() en second.join() op elke thread afzonderlijk. Het resultaat is daarom 2000, ongeacht de uitvoeringsvolgorde. Het voorbeeld gebruikt voorzieningen die beschikbaar zijn in C++23; de opgegeven compilatiestandaard bevestigt geen productieomgeving. De aangehaalde bron is een zich ontwikkelend concept van een standaard, geen vastgelegde C++23-editie.

Voorbeelden

#include <iostream>
#include <mutex>
#include <thread>

int main() {
    std::mutex m;
    int counter = 0;

    auto increment = [&] {
        for (int i = 0; i < 1000; ++i) {
            std::lock_guard<std::mutex> guard(m);
            ++counter;
        }
    };

    std::thread first(increment);
    std::thread second(increment);
    first.join();
    second.join();

    std::cout << counter << '\n';
}

Resultaat

2000

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