Namensräume
Varianten
Aktionen

std::recursive_mutex

Von cppreference.com
< cpp‎ | thread
 
C++
 
Bibliothek für nebenläufige Programmierung
Threads
(C++11)
(C++20)
(C++17)(C++17)
this_thread Namespace
(C++11)
(C++11)
(C++11)
(C++11)
Kooperatives Beenden
Gegenseitiger Ausschluss
(C++11)
recursive_mutex
(C++11)
(C++17)
Allgemeines Sperrungsmanagement
(C++11)
(C++11)
(C++17)
(C++11)
(C++14)
(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)
Bedingungsvariablen
(C++11)
(C++11)
(C++11)
(C++11)
Semaphoren
(C++20)(C++20)
Latches und Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Sichere Wiederherstellung
(C++26)
(C++26)
(C++26)
Hazard Pointer
(C++26)
(C++26)
(C++26)
Atomare Typen
(C++11)
(C++20)
(C++11)
Initialisierung von atomaren Typen
(C++11)(veraltet in C++20)
(C++11)(veraltet in C++20)
(C++11)
Speicherordnung
(C++11)
(C++11)(deprecated in C++26)
(C++11)
(C++11)
Freie Funktionen für atomare Operationen
(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)
Freie Funktionen für atomare Flags
(C++11)(C++11)
(C++11)(C++11)
(C++20)(C++20)
(C++20)(C++20)
(C++20)
(C++20)
 
std::recursive_mutex
 
Definiert in Header <mutex>
class recursive_mutex;
 (seit C++11)

Die Klasse recursive_mutex ist eine Synchronisationsprimitivität, die verwendet werden kann, um gemeinsame Daten vor gleichzeitigem Zugriff durch mehrere Threads zu schützen.

recursive_mutex bietet exklusive, rekursive Besitzsemantik.

  • Ein aufrufender Thread besitzt ein recursive_mutex für einen Zeitraum, der beginnt, wenn er erfolgreich entweder lock oder try_lock aufruft. Während dieser Zeit kann der Thread zusätzliche Aufrufe von lock oder try_lock tätigen. Der Zeitraum des Besitzes endet, wenn der Thread eine entsprechende Anzahl von Aufrufen von unlock tätigt.
  • Wenn ein Thread ein recursive_mutex besitzt, blockieren alle anderen Threads (bei Aufrufen von lock) oder erhalten einen Rückgabewert false (für try_lock), wenn sie versuchen, den Besitz des recursive_mutex zu beanspruchen.
  • Die maximale Anzahl von Sperren für ein recursive_mutex ist nicht spezifiziert, aber nachdem diese Anzahl erreicht ist, lösen Aufrufe von lock eine std::system_error aus und Aufrufe von try_lock geben false zurück.

Das Verhalten eines Programms ist undefiniert, wenn ein recursive_mutex zerstört wird, während es noch von einem Thread besessen wird. Die Klasse recursive_mutex erfüllt alle Anforderungen von Mutex und StandardLayoutType.

Inhalt

[bearbeiten] Mitgliedstypen

Mitgliedertyp Definition
native_handle_type (optional*) implementierungsabhängig[bearbeiten]

[bearbeiten] Mitgliederfunktionen

 konstruiert den Mutex
(public member function) [edit]
 zerstört den Mutex
(public member function) [edit]
operator=
[gelöscht]
 nicht kopierbar
(public member function) [edit]
Sperren
 sperrt den Mutex, blockiert, wenn der Mutex nicht verfügbar ist
(public member function) [edit]
 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]
Native handle
 gibt das implementierungsabhängige native Handle-Objekt zurück
(public member function) [bearbeiten]

[bearbeiten] Beispiel

Ein Anwendungsfall für recursive_mutex ist der Schutz des gemeinsamen Zustands in einer Klasse, deren Member-Funktionen sich gegenseitig aufrufen können.

Führen Sie diesen Code aus
#include <iostream>
#include <mutex>
#include <thread>
 
class X
{
    std::recursive_mutex m;
    std::string shared;
public:
    void fun1()
    {
        std::lock_guard<std::recursive_mutex> lk(m);
        shared = "fun1";
        std::cout << "in fun1, shared variable is now " << shared << '\n';
    }
    void fun2()
    {
        std::lock_guard<std::recursive_mutex> lk(m);
        shared = "fun2";
        std::cout << "in fun2, shared variable is now " << shared << '\n';
        fun1(); // recursive lock becomes useful here
        std::cout << "back in fun2, shared variable is " << shared << '\n';
    }
};
 
int main() 
{
    X x;
    std::thread t1(&X::fun1, &x);
    std::thread t2(&X::fun2, &x);
    t1.join();
    t2.join();
}

Mögliche Ausgabe

in fun1, shared variable is now fun1
in fun2, shared variable is now fun2
in fun1, shared variable is now fun1
back in fun2, shared variable is fun1

[bearbeiten] Siehe auch

(C++11)
 bietet grundlegende Gegenseitiger-Ausschluss-Funktionen
(Klasse) [bearbeiten]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/thread/recursive_mutex&oldid=161215"