<shared_mutex>

Der <shared_mutex> Header stellt Synchronisierungsgrundtypen zum Schutz freigegebener Daten bereit, auf die von mehreren Threads zugegriffen werden kann. Zusätzlich zu der exklusiven Zugriffssteuerung, die von Mutex-Klassen bereitgestellt wird, ermöglichen die gemeinsamen Mutex-Klassen auch den gemeinsamen Besitz durch mehrere Threads für den nicht exklusiven Zugriff. Gemeinsame Mutexe können verwendet werden, um Ressourcen zu steuern, die von mehreren Threads gelesen werden können, ohne dass eine Racebedingung verursacht wird, aber ausschließlich von einem einzelnen Thread geschrieben werden müssen.

Der Header <shared_mutex> definiert die Klassen shared_mutex und shared_timed_mutex, die Klassenvorlage shared_lockund die Vorlagenfunktion swap für die gemeinsame Mutex-Unterstützung.

Syntax

namespace std {
    class shared_mutex;
    class shared_timed_mutex;
    template <class Mutex>
class shared_lock;
    template <class Mutex>
void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
}

Hinweise

Eine Instanz von Klasse shared_mutex ist ein gemeinsamer Mutex-Typ, ein Typ, der den gemeinsamen Besitz eines Mutex innerhalb eines Bereichs steuert. Ein gemeinsamer Mutex-Typ erfüllt alle Anforderungen eines Mutex-Typs sowie Member zur Unterstützung des gemeinsamem nicht exklusiven Besitzes.

Ein gemeinsamer Mutex unterstützt die zusätzlichen Methoden lock_shared, unlock_shared und try_lock_shared:

• Die lock_shared-Methode blockiert den aufrufenden Thread, bis der Thread den gemeinsamen Besitz des Mutex erlangt.

• Die unlock_shared-Methode gibt den Besitz des Mutex frei, in dem der aufrufende Thread steht.

• Die try_lock_shared-Methode versucht, ohne Blockierung in den Besitz des Mutex zu gelangen. Der Rückgabetyp ist in bool konvertierbar und weist den Wert true auf, wenn die Methode den Besitz erlangt, andernfalls false.

Die Klasse shared_timed_mutex ist ein gemeinsamer zeitgesteuerter Mutex-Typ, ein Typ, der die Anforderungen eines gemeinsamen Mutex-Typs und eines zeitgesteuerten Mutex-Typs erfüllt.

Ein gemeinsamer zeitgesteuerter Mutex-Typ unterstützt die zusätzlichen Methoden try_lock_shared_for und try_lock_shared_until:

• Die try_lock_shared_for-Methode versucht, den gemeinsamen Besitz des Mutex abzurufen, bis die vom Parameter angegebene Dauer verstrichen ist. Wenn die Dauer nicht positiv ist, entspricht die Methode try_lock_shared. Die Methode gibt nicht innerhalb der angegebenen Dauer zurück, sofern der gemeinsame Besitz nicht abgerufen wird. Der Rückgabewert ist true, wenn die Methode den gemeinsamen Besitz abruft, andernfalls ist er false.

• Die try_lock_shared_until Methode versucht, den gemeinsamen Besitz des Mutex abrufen, bis die angegebene absolute Zeit abgelaufen ist. Wenn die angegebene Zeit bereits verstrichen ist, entspricht die Methode try_lock_shared. Die Methode gibt nicht vor der angegebenen Zeit zurück, wenn der gemeinsame Besitz nicht abgerufen wird. Der Rückgabewert ist true, wenn die Methode den gemeinsamen Besitz abruft, andernfalls ist er false.

Die shared_lock Klassenvorlage erweitert die Unterstützung für das zeitbasierte Sperren und die Übertragung des Besitzes auf einen freigegebenen Mutex. Der Besitz des Mutex kann bei oder nach der Erstellung abgerufen und an ein anderes shared_lock-Objekt übertragen werden. Objekte vom Typ shared_lock können verschoben, aber nicht kopiert werden.

Klassen

shared_mutex-Klasse

Klasse shared_mutex implementiert einen nicht rekursiven Mutex mit gemeinsamer Besitzsemantik.

class shared_mutex {
public:
   shared_mutex();
   ~shared_mutex();
   shared_mutex(const shared_mutex&) = delete;
   shared_mutex& operator=(const shared_mutex&) = delete;
   // Exclusive ownership
   void lock();
   // blocking
   bool try_lock();
   void unlock();
   // Shared ownership
   void lock_shared();
   // blocking
   bool try_lock_shared();
   void unlock_shared();
   // Getters
   typedef void** native_handle_type; // implementation defined
   native_handle_type native_handle();
   };

shared_timed_mutex-Klasse

Klasse shared_timed_mutex implementiert einen nicht rekursiven Mutex mit gemeinsamer Besitz-Semantik, die den Anforderungen eines zeitgesteuerten Mutex-Typs entspricht.

class shared_timed_mutex {
public:
   shared_timed_mutex();
   ~shared_timed_mutex();
   shared_timed_mutex(const shared_timed_mutex&) = delete;
   shared_timed_mutex& operator=(const shared_timed_mutex&) = delete;
   // Exclusive ownership
   void lock();
   // blocking
   bool try_lock();
   template <class Rep, class Period>
   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
   template <class Clock, class Duration>
   bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
   void unlock();
   // Shared ownership
   void lock_shared();
   // blocking
   bool try_lock_shared();
   template <class Rep, class Period>
   bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time);
   template <class Clock, class Duration>
   bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time);
   void unlock_shared();
   };

shared_lock-Klasse

Die Klassenvorlage shared_lock steuert den gemeinsamen Besitz eines freigegebenen Mutex-Objekts innerhalb eines Bereichs. Bei dem Vorlagenparameter muss es sich um einen gemeinsamen Mutex-Typ handeln.

class shared_lock {
public:
   typedef Mutex mutex_type;
   shared_lock() noexcept;
   explicit shared_lock(mutex_type& m);
   // blocking
   shared_lock(mutex_type& m, defer_lock_t) noexcept;
   shared_lock(mutex_type& m, try_to_lock_t);
   shared_lock(mutex_type& m, adopt_lock_t);
   template <class Clock, class Duration>
   shared_lock(mutex_type& m,
   const chrono::time_point<Clock, Duration>& abs_time);
   template <class Rep, class Period>
   shared_lock(mutex_type& m,
   const chrono::duration<Rep, Period>& rel_time);
   ~shared_lock();
   shared_lock(shared_lock const&) = delete;
   shared_lock& operator=(shared_lock const&) = delete;
   shared_lock(shared_lock&& u) noexcept;
   shared_lock& operator=(shared_lock&& u) noexcept;
   void lock();
   // blocking
   bool try_lock();
   template <class Rep, class Period>
   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
   template <class Clock, class Duration>
   bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
   void unlock();
   // Setters
   void swap(shared_lock& u) noexcept;
   mutex_type* release() noexcept;
   // Getters
   bool owns_lock() const noexcept;
   explicit operator bool () const noexcept;
   mutex_type* mutex() const noexcept;
private:
   mutex_type* pm; // exposition only
   bool owns; // exposition only
   };

Functions

swap

Tauscht die shared_lock-Objekte.

template <class Mutex>
void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;

Tauscht den Inhalt von zwei shared_lock-Objekten aus. Identisch mit x.swap(y).

Anforderungen

Header:<shared_mutex>

Namespace: std

Siehe auch

Headerdateienreferenz
<mutex>