Namensräume
Varianten
Aktionen

std::shared_timed_mutex::lock

Von cppreference.com
 
 
Bibliothek für nebenläufige Programmierung
Threads
(C++11)
(C++20)
this_thread Namespace
(C++11)
(C++11)
(C++11)
Kooperatives Beenden
Gegenseitiger Ausschluss
(C++11)
Allgemeines Sperrungsmanagement
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Bedingungsvariablen
(C++11)
Semaphoren
Latches und Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
Sichere Wiederherstellung
(C++26)
Hazard Pointer
Atomare Typen
(C++11)
(C++20)
Initialisierung von atomaren Typen
(C++11)(veraltet in C++20)
(C++11)(veraltet in C++20)
Speicherordnung
(C++11)(deprecated in C++26)
Freie Funktionen für atomare Operationen
Freie Funktionen für atomare Flags
 
 
void lock();
(seit C++14)

Sperrt die Mutex. Wenn ein anderer Thread die Mutex bereits gesperrt hat, blockiert ein Aufruf von lock die Ausführung, bis die Sperre erworben wurde.

Wenn lock von einem Thread aufgerufen wird, der die mutex bereits in irgendeinem Modus (geteilt oder exklusiv) besitzt, ist das Verhalten undefiniert.

Vorherige unlock()-Operationen auf derselben Mutex synchronisieren mit (wie in std::memory_order definiert) dieser Operation.

Inhalt

[bearbeiten] Parameter

(keine)

[bearbeiten] Rückgabewert

(keine)

[bearbeiten] Ausnahmen

Wirft std::system_error bei Fehlern, einschließlich Fehlern des zugrunde liegenden Betriebssystems, die verhindern, dass lock seine Spezifikationen erfüllt. Die Mutex ist im Falle einer geworfenen Ausnahme nicht gesperrt.

[bearbeiten] Hinweise

lock() wird normalerweise nicht direkt aufgerufen: std::unique_lock, std::scoped_lock und std::lock_guard werden zur Verwaltung exklusiver Sperren verwendet.

Geteilte Mutex unterstützen keine direkte Umwandlung von geteiltem in exklusiven Besitzmodus: Die geteilte Sperre muss mit unlock_shared() aufgehoben werden, bevor exklusiver Besitz mit lock() erlangt werden kann. boost::upgrade_mutex kann zu diesem Zweck verwendet werden.

[bearbeiten] Beispiel

Dieses Beispiel zeigt, wie lock und unlock zum Schutz gemeinsamer Daten verwendet werden können.

#include <chrono>
#include <iostream>
#include <mutex>
#include <thread>
 
int g_num = 0; // protected by g_num_mutex
std::mutex g_num_mutex;
 
void slow_increment(int id) 
{
    for (int i = 0; i < 3; ++i)
    {
        g_num_mutex.lock(); 
        ++g_num;
        // note, that the mutex also syncronizes the output
        std::cout << "id: " << id << ", g_num: " << g_num << '\n';
        g_num_mutex.unlock();
 
        std::this_thread::sleep_for(std::chrono::milliseconds(234));
    }
}
 
int main()
{
    std::thread t1{slow_increment, 0};
    std::thread t2{slow_increment, 1};
    t1.join();
    t2.join();
}

Mögliche Ausgabe

id: 0, g_num: 1
id: 1, g_num: 2
id: 1, g_num: 3
id: 0, g_num: 4
id: 0, g_num: 5
id: 1, g_num: 6

[bearbeiten] Siehe auch

versucht, den Mutex zu sperren, kehrt zurück, wenn der Mutex nicht verfügbar ist
(public member function) [edit]
entsperrt den Mutex
(public member function) [edit]
C-Dokumentation für mtx_lock