<shared_mutex>

Hlavička <shared_mutex> poskytuje primitivy synchronizace pro ochranu sdílených dat, ke kterým má přístup více vláken. Kromě výhradního řízení přístupu poskytovaného třídami mutex umožňují sdílené třídy mutex také sdílené vlastnictví několika vlákny pro nevýlučné přístup. Sdílené mutexy lze použít k řízení prostředků, které lze číst několika vlákny, aniž by to způsobilo časování, ale musí být zapsáno výhradně jedním vláknem.

Hlavička <shared_mutex> definuje třídy shared_mutex a shared_timed_mutexšablonu třídy shared_locka funkci swap šablony pro podporu sdíleného mutexu.

Třídy	Popis
shared_mutex – třída	Typ sdíleného mutexu, který může být uzamčen výhradně jedním agentem nebo nesdíleným více agenty.
shared_timed_mutex – třída	Typ mutex sdíleného časového limitu, který může být uzamčen výhradně jedním agentem nebo nesdíleným více agenty.
shared_lock – třída	Šablona třídy, která zabalí sdílený mutex, aby podporovala operace časového uzamčení a nevýlučné sdílení více agentů.

Funkce	Popis
vyměnit	Prohodí obsah sdílených objektů mutex odkazovaných parametry funkce.

Syntaxe

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;
}

Poznámky

Instance třídy shared_mutex je sdílený typ mutex, typ, který řídí sdílené vlastnictví mutex v rámci oboru. Sdílený typ mutex splňuje všechny požadavky typu mutex a také členy na podporu sdíleného nevýlučného vlastnictví.

Typ sdíleného mutexu podporuje další metody lock_shared, unlock_shareda try_lock_shared:

• Metoda lock_shared blokuje volající vlákno, dokud vlákno nezískne sdílené vlastnictví mutex.

• Metoda unlock_shared uvolní sdílené vlastnictví mutex uchovávaného volajícím vláknem.

• Metoda try_lock_shared se pokusí získat sdílené vlastnictví mutex bez blokování. Jeho návratový typ je konvertibilní na bool a je,pokud true metoda získá vlastnictví, ale je jinak false.

Třída shared_timed_mutex je typ sdíleného časového mutexu, typ, který splňuje požadavky typu sdíleného mutexu i typu časového typu mutex.

Typ mutex sdíleného časového limitu podporuje další metody try_lock_shared_for a try_lock_shared_until:

• Metoda try_lock_shared_for se pokusí získat sdílené vlastnictví mutex, dokud doba trvání určená parametrem nepřejde. Pokud doba trvání není kladná, metoda je ekvivalentní try_lock_shared. Metoda nevrací během zadané doby trvání, pokud není získáno sdílené vlastnictví. Jeho návratová hodnota je true , pokud metoda získá vlastnictví, ale je jinak false.

• Metoda try_lock_shared_until se pokusí získat sdílené vlastnictví mutex, dokud zadaný absolutní čas nepřejde. Pokud zadaný čas již uplynul, je metoda ekvivalentní try_lock_shared. Metoda nevrací před časem určeným, pokud není získáno sdílené vlastnictví. Jeho návratová hodnota je true , pokud metoda získá vlastnictví, ale je jinak false.

Šablona shared_lock třídy rozšiřuje podporu pro časově zamykání a přenos vlastnictví do sdíleného mutexu. Vlastnictví mutexu lze získat při konstrukci nebo po něm a může být převedeno na jiný shared_lock objekt. Objekty typu shared_lock lze přesunout, ale ne zkopírovat.

Upozorňující

Počínaje sadou Visual Studio 2015 jsou typy synchronizace standardní knihovny C++ založené na primitivách synchronizace Systému Windows a už nepoužívají ConcRT (s výjimkou případů, kdy je cílovou platformou Systém Windows XP). Typy definované v <shared_mutex> by neměly být použity s žádnými typy nebo funkcemi ConcRT.

Třídy

shared_mutex – třída

Třída shared_mutex implementuje ne rekurzivní mutex se sdílenou sémantikou vlastnictví.

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 – třída

Třída shared_timed_mutex implementuje nerekurzivní mutex se sémantikou sdíleného vlastnictví, která splňuje požadavky časového typu mutex.

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 – třída

Šablona shared_lock třídy řídí sdílené vlastnictví sdíleného objektu mutex v rámci oboru. Parametr šablony musí být sdílený typ mutex.

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
   };

Funkce

swap

Prohodí shared_lock objekty.

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

Vymění obsah dvou shared_lock objektů. Ve skutečnosti stejné jako x.swap(y).

Požadavky

Záhlaví:<shared_mutex>

Namespace: std

Viz také

Referenční informace k souborům hlaviček
<mutex>