C++ Academy · Lektion

std::mutex, lock_guard och unique_lock

Skydda delat tillstånd med mutexar och RAII-baserade låshjälpare

Lektion 2 av 414 steg

std::mutex, lock_guard och unique_lock är en gratis lektion i C++ Academy på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för C++ Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C++ Academy innehåller totalt 4 lektioner.

Varför mutex?

När flera trådar får åtkomst till samma data tävlar de om den. En mutex garanterar ömsesidig uteslutning: endast en tråd åt gången håller låset.

Grunderna i std::mutex

Skapa, lås och lås upp. Manuell låsning leder lätt till fel — använd alltid RAII-hjälpmedel.

#include <mutex>
std::mutex mtx;

mtx.lock();
// critical section
mtx.unlock();

std::lock_guard: RAII-lås

Det enklaste RAII-låset. Det låser i konstruktorn och låser upp i destruktorn. Det fungerar utmärkt för kritiska sektioner som inte kastar undantag.

std::mutex mtx;
int counter = 0;

void increment() {
    std::lock_guard<std::mutex> lock(mtx);
    ++counter;
}

std::scoped_lock (C++17)

Som lock_guard, men kan låsa flera mutexar samtidigt utan deadlock. Föredra det i modern kod.

#include <mutex>
std::scoped_lock lock(mtx1, mtx2, mtx3);  // locks all atomically

std::unique_lock: flexibelt lås

Fler funktioner än lock_guard:

Kan låsas upp och låsas igen under samma scope
Kan flyttas (ägarskapet kan överföras)
Används med villkorsvariabler

std::unique_lock<std::mutex> lock(mtx);
lock.unlock();        // release temporarily
// ... do something without the lock ...
lock.lock();           // reacquire

Undvika deadlock

Två trådar kan hamna i deadlock om de förvärvar lås i olika ordning. Förvärva lås i en konsekvent global ordning eller använd std::scoped_lock med flera mutexar.

std::lock för flera mutexar

Före C++17 använder ni std::lock för att förvärva flera mutexar atomärt. C++17:s std::scoped_lock är renare.

Rekursiv mutex

std::recursive_mutex låter en tråd låsa samma mutex flera gånger. Det är vanligtvis ett tecken på designproblem — refaktorera i stället.

try_lock och timed_mutex

try_lock returnerar omedelbart om låset redan innehas. std::timed_mutex stöder tidsbegränsade försök att låsa.

Läsar-skrivar-lås

std::shared_mutex (C++17) tillåter många samtidiga läsare eller en ensam exklusiv skrivare. Använd det för arbetsbelastningar som domineras av läsning.

std::shared_mutex sm;
void read()  { std::shared_lock lk(sm);   /* read */ }
void write() { std::unique_lock lk(sm);   /* write */ }

Avvägning av låsgranularitet

För grovkornig låsning försämrar samtidigheten. För finkornig låsning medför extra kostnader. Profilera och finjustera.

Låsfria alternativ

Överväg låsfria datastrukturer vid hög konkurrens om resurser (atomics, låsfria köer). De är mycket svårare att skriva korrekt — använd dem endast när det behövs och har verifierats.

Snabbkontroll

Vilket RAII-lås bör ni föredra när ni låser flera mutexar samtidigt?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Använd std::lock_guard för enkla kritiska sektioner, std::scoped_lock för flera mutexar och std::unique_lock när ni behöver flexibilitet (villkorsvariabler, manuell upplåsning). Använd alltid RAII — anropa aldrig lock/unlock manuellt.

Gratis att börja

Lär dig C++ med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 51
Lektioner: 203

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”std::mutex, lock_guard och unique_lock” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen C++ Academy, inklusive ”std::mutex, lock_guard och unique_lock”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i C++ Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”std::mutex, lock_guard och unique_lock”?

Skydda delat tillstånd med mutexar och RAII-baserade låshjälpare Ni övar på C++ Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig C++ Academy?

Du behöver inga förkunskaper. Utbildningen i C++ Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”std::mutex, lock_guard och unique_lock”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här C++ Academy-lektionen?

Ja. Varje C++ Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till C++ Academy