Namespaces
Variants

std:: shared_timed_mutex

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
(C++11)
(C++11)
shared_timed_mutex
(C++14)
Generic lock management
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::shared_timed_mutex
Definiert im Header <shared_mutex>
class shared_timed_mutex ;
(seit C++14)

Die shared_timed_mutex -Klasse ist ein Synchronisierungsprimitive, das verwendet werden kann, um gemeinsame Daten vor gleichzeitigem Zugriff durch mehrere Threads zu schützen. Im Gegensatz zu anderen Mutex-Typen, die exklusiven Zugriff ermöglichen, hat eine shared_timed_mutex zwei Zugriffsebenen:

  • exclusive - nur ein Thread kann den Mutex besitzen.
  • shared - mehrere Threads können gemeinsamen Besitz desselben Mutex haben.

Shared Mutexe werden normalerweise in Situationen verwendet, in denen mehrere Leser gleichzeitig auf dieselbe Ressource zugreifen können, ohne Datenrennen zu verursachen, aber nur ein Schreiber dies tun kann.

Ähnlich wie bei timed_mutex bietet shared_timed_mutex die Möglichkeit, den Besitz eines shared_timed_mutex mit einem Timeout über die try_lock_for() -, try_lock_until() -, try_lock_shared_for() - und try_lock_shared_until() -Memberfunktionen zu beanspruchen.

Die shared_timed_mutex -Klasse erfüllt alle Anforderungen von SharedTimedMutex und StandardLayoutType .

Inhaltsverzeichnis

Memberfunktionen

Konstruiert den Mutex
(öffentliche Elementfunktion)
Zerstört den Mutex
(öffentliche Elementfunktion)
operator=
[deleted]
Nicht kopierzuweisbar
(öffentliche Elementfunktion)
Exklusives Sperren
Sperrt den Mutex, blockiert falls der Mutex nicht verfügbar ist
(öffentliche Elementfunktion)
Versucht den Mutex zu sperren, kehrt zurück falls der Mutex nicht verfügbar ist
(öffentliche Elementfunktion)
Versucht den Mutex zu sperren, kehrt zurück falls der Mutex für die
angegebene Timeout-Dauer nicht verfügbar war
(öffentliche Elementfunktion)
Versucht den Mutex zu sperren, kehrt zurück falls der Mutex
nicht verfügbar war bis der angegebene Zeitpunkt erreicht wurde
(öffentliche Elementfunktion)
Entsperrt den Mutex
(öffentliche Elementfunktion)
Gemeinsames Sperren
Sperrt den Mutex für gemeinsamen Besitz, blockiert falls der Mutex nicht verfügbar ist
(öffentliche Elementfunktion)
Versucht den Mutex für gemeinsamen Besitz zu sperren, kehrt zurück falls der Mutex nicht verfügbar ist
(öffentliche Elementfunktion)
Versucht den Mutex für gemeinsamen Besitz zu sperren, kehrt zurück falls der Mutex
für die angegebene Timeout-Dauer nicht verfügbar war
(öffentliche Elementfunktion)
Versucht den Mutex für gemeinsamen Besitz zu sperren, kehrt zurück falls der Mutex
nicht verfügbar war bis der angegebene Zeitpunkt erreicht wurde
(öffentliche Elementfunktion)
Entsperrt den Mutex (gemeinsamer Besitz)
(öffentliche Elementfunktion)

Hinweise

Feature-Test Makro Wert Standard Funktion
__cpp_lib_shared_timed_mutex 201402L (C++14) std::shared_timed_mutex

Beispiel

Dieser Abschnitt ist unvollständig
Grund: ein motivierendes Beispiel erstellen

Ein Kopierzuweisungsoperator für eine Klasse, die Ressourcen verwaltet, die mehrere Leser, aber nur einen Schreiber handhaben können.

Diesen Code ausführen 
#include <mutex>
#include <shared_mutex>
class R
{
    mutable std::shared_timed_mutex mut;
    /* data */
public:
    R& operator=(const R& other)
    {
        // requires exclusive ownership to write to *this
        std::unique_lock<std::shared_timed_mutex> lhs(mut, std::defer_lock);
        // requires shared ownership to read from other
        std::shared_lock<std::shared_timed_mutex> rhs(other.mut, std::defer_lock);
        std::lock(lhs, rhs);
        /* assign data */
        return *this;
    }
};
int main()
{
    R r;
}