Namespaces
Variants

std:: lock_guard

From cppreference.net
C++
Concurrency support library
Threads
(C++11)
(C++20)
(C++17) (C++17)
this_thread namespace
(C++11)
(C++11)
Cooperative cancellation
Mutual exclusion
Generic lock management
(C++11)
lock_guard
(C++11)
(C++17)
(C++11)
(C++14)
(C++11)
(C++11)
Condition variables
(C++11)
(C++11)
(C++11)
(C++11)
Semaphores
(C++20) (C++20)
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Safe reclamation
Hazard pointers
(C++26)
(C++26)
(C++26)
Atomic types
(C++11)
(C++20)
(C++11)
Initialization of atomic types
(C++11) (deprecated in C++20)
(C++11) (deprecated in C++20)
(C++11)
Memory ordering
(C++11)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
Free functions for atomic operations
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11) (C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++26) (C++26)
(C++26) (C++26)
(C++11)
(C++20) (C++20)
(C++20)
(C++20)
Free functions for atomic flags
(C++11) (C++11)
(C++11) (C++11)
(C++20) (C++20)
(C++20) (C++20)
(C++20)
(C++20)
std::lock_guard
Definiert im Header <mutex>
template < class Mutex >
class lock_guard ;
(seit C++11)

Die Klasse lock_guard ist ein Mutex-Wrapper, der einen praktischen RAII-Stil Mechanismus bereitstellt, um einen Mutex für die Dauer eines gültigen Blocks zu besitzen.

Wenn ein lock_guard -Objekt erstellt wird, versucht es, den Besitz des übergebenen Mutex zu übernehmen. Wenn der Kontrollfluss den Gültigkeitsbereich verlässt, in dem das lock_guard -Objekt erstellt wurde, wird der lock_guard zerstört und der Mutex freigegeben.

Die lock_guard -Klasse ist nicht kopierbar.

Inhaltsverzeichnis

Template-Parameter

Mutex - der Typ des zu sperrenden Mutex. Der Typ muss die BasicLockable Anforderungen erfüllen

Mitgliedertypen

Mitgliedstyp Definition
mutex_type Mutex

Memberfunktionen

Konstruiert einen lock_guard , optional sperrend das gegebene Mutex
(öffentliche Elementfunktion)
zerstört das lock_guard -Objekt, entsperrt das zugrundeliegende Mutex
(öffentliche Elementfunktion)
operator=
[deleted]
nicht kopierzuweisbar
(öffentliche Elementfunktion)

Hinweise

Ein häufiger Anfängerfehler ist es, zu vergessen, einer lock_guard -Variable einen Namen zu geben, wie beispielsweise durch std :: lock_guard { mtx } . Dies konstruiert ein PRvalue-Objekt, das sofort zerstört wird, wodurch tatsächlich keine Sperre erstellt wird, die einen Mutex für den Rest des Gültigkeitsbereichs hält.

std::scoped_lock bietet eine Alternative zu lock_guard , die die Möglichkeit bietet, mehrere Mutexe unter Verwendung eines Deadlock-Vermeidungsalgorithmus zu sperren.

(seit C++17)

Beispiel

Demonstriert sichere und unsichere Inkrementierungen einer volatile-Variable durch zwei Threads.

Code ausführen 
#include <iostream>
#include <mutex>
#include <string_view>
#include <syncstream>
#include <thread>
volatile int g_i = 0;
std::mutex g_i_mutex;  // schützt g_i
void safe_increment(int iterations)
{
    const std::lock_guard<std::mutex> lock(g_i_mutex);
    while (iterations-- > 0)
        g_i = g_i + 1;
    std::cout << "thread #" << std::this_thread::get_id() << ", g_i: " << g_i << '\n';
    // g_i_mutex wird automatisch freigegeben, wenn lock den Gültigkeitsbereich verlässt
}
void unsafe_increment(int iterations)
{
    while (iterations-- > 0)
        g_i = g_i + 1;
    std::osyncstream(std::cout) << "thread #" << std::this_thread::get_id()
                                << ", g_i: " << g_i << '\n';
}
int main()
{
    auto test = [](std::string_view fun_name, auto fun)
    {
        g_i = 0;
        std::cout << fun_name << ":\nbefore, g_i: " << g_i << '\n';
        {
            std::jthread t1(fun, 1'000'000);
            std::jthread t2(fun, 1'000'000);
        }
        std::cout << "after, g_i: " << g_i << "\n\n";
    };
    test("safe_increment", safe_increment);
    test("unsafe_increment", unsafe_increment);
}

Mögliche Ausgabe: 

safe_increment:
before, g_i: 0
thread #140121493231360, g_i: 1000000
thread #140121484838656, g_i: 2000000
after, g_i: 2000000
unsafe_increment:
before, g_i: 0
thread #140121484838656, g_i: 1028945
thread #140121493231360, g_i: 1034337
after, g_i: 1034337

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 2981 C++17 redundanter Deduction Guide von lock_guard<Mutex> wurde bereitgestellt entfernt

Siehe auch

(C++11)
implementiert beweglichen Mutex-Eigentums-Wrapper
(Klassen-Template)
(C++17)
Deadlock-vermeidender RAII-Wrapper für mehrere Mutexe
(Klassen-Template)