<shared_mutex>

Nagłówek <shared_mutex> zawiera typy pierwotne synchronizacji na potrzeby ochrony udostępnionych danych, do których można uzyskać dostęp przez wiele wątków. Oprócz wyłącznej kontroli dostępu zapewnianej przez klasy mutex współużytkowane klasy mutex umożliwiają również współdzielenie własności przez wiele wątków na potrzeby dostępu bez wyłącznych. Udostępnione mutexy mogą służyć do kontrolowania zasobów, które mogą być odczytywane przez kilka wątków bez powodowania stanu wyścigu, ale muszą być zapisywane wyłącznie przez jeden wątek.

Nagłówek <shared_mutex> definiuje klasy shared_mutex i shared_timed_mutex, szablon shared_lockklasy i funkcję swap szablonu dla współużytkowanej obsługi mutex.

Klasy	opis
klasa shared_mutex	Współużytkowany typ mutexu, który może być zablokowany wyłącznie przez jednego agenta lub współużytkowany przez wielu agentów.
klasa shared_timed_mutex	Udostępniony typ mutexu czasowego, który może być zablokowany wyłącznie przez jednego agenta lub udostępniony nie wyłącznie przez wielu agentów.
klasa shared_lock	Szablon klasy, który opakowuje udostępniony mutex w celu obsługi operacji blokady czasowej i udostępniania bez wyłącznych przez wielu agentów.

Funkcje	opis
zamiana	Zamienia zawartość udostępnionych obiektów mutex, do których odwołuje się parametr funkcji.

Składnia

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

Uwagi

Wystąpienie klasy shared_mutex jest typem współużytkowanego mutexu, który kontroluje współdzieloną własność mutexu w zakresie. Współużytkowany typ mutex spełnia wszystkie wymagania typu mutex, a także elementy członkowskie do obsługi współużytkowanej własności bez wyłączności.

Współużytkowany typ mutex obsługuje dodatkowe metody lock_shared, unlock_sharedi try_lock_shared:

• Metoda lock_shared blokuje wątek wywołujący, dopóki wątek nie uzyska współużytkowanej własności mutexu.

• Metoda unlock_shared zwalnia współwłasność mutexu przechowywanego przez wątek wywołujący.

• Metoda try_lock_shared próbuje uzyskać współdzieloną własność mutexu bez blokowania. Jego zwracany typ jest konwertowany na bool i jest true , jeśli metoda uzyskuje własność, ale w przeciwnym razie false.

Klasa shared_timed_mutex jest współużytkowanym typem mutex czasowym, typem spełniającym wymagania zarówno typu współużytkowanego mutexu, jak i typu czasowego mutexu.

Udostępniony typ mutexu czasowego obsługuje dodatkowe metody try_lock_shared_for i try_lock_shared_until:

• Metoda try_lock_shared_for próbuje uzyskać współdzieloną własność mutexu, dopóki czas trwania określony przez parametr nie zostanie przekazany. Jeśli czas trwania nie jest dodatni, metoda jest równoważna .try_lock_shared Metoda nie zwraca się w określonym czasie trwania, chyba że zostanie uzyskana własność współdzielona. Jego wartość zwracana jest true wtedy, gdy metoda uzyskuje własność, ale w przeciwnym razie falsejest .

• Metoda try_lock_shared_until próbuje uzyskać współdzieloną własność mutexu, dopóki nie upłynął określony czas bezwzględny. Jeśli określony czas został już przekazany, metoda jest równoważna metodzie try_lock_shared. Metoda nie zwraca się przed określonym czasem, chyba że zostanie uzyskana własność współdzielona. Jego wartość zwracana jest true wtedy, gdy metoda uzyskuje własność, ale w przeciwnym razie falsejest .

Szablon shared_lock klasy rozszerza obsługę czasowego blokowania i przenoszenia własności do udostępnionego mutexu. Własność mutexu można uzyskać w lub po budowie i może zostać przeniesiona do innego shared_lock obiektu. Obiekty typu shared_lock można przenosić, ale nie kopiowane.

Ostrzeżenie

Począwszy od programu Visual Studio 2015, typy synchronizacji biblioteki standardowej języka C++ są oparte na typach pierwotnych synchronizacji systemu Windows i nie używają już narzędzia ConcRT (z wyjątkiem sytuacji, gdy platforma docelowa to Windows XP). Typy zdefiniowane w programie <shared_mutex> nie powinny być używane z żadnymi typami lub funkcjami ConcRT.

Klasy

klasa shared_mutex

Klasa shared_mutex implementuje niecykliczny mutex z semantyka współdzieloną własnością.

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

klasa shared_timed_mutex

Klasa shared_timed_mutex implementuje niecykliczny mutex z semantyki współużytkowanej własności, która spełnia wymagania typu czasowego mutexu.

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

klasa shared_lock

Szablon shared_lock klasy kontroluje współdzieloną własność współużytkowanego obiektu mutex w zakresie. Parametr szablonu musi być udostępnionym typem 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
   };

Funkcje

swap

shared_lock Zamienia obiekty.

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

Wymienia zawartość dwóch shared_lock obiektów. Skutecznie tak samo jak x.swap(y).

Wymagania

Nagłówek:<shared_mutex>

Przestrzeń nazw: std

Zobacz też

Odwołanie do plików nagłówka
<mutex>