<shared_mutex>

Üst bilgi, <shared_mutex> birden çok iş parçacığı tarafından erişilebilen paylaşılan verilerin korunması için eşitleme temel öğelerini sağlar. Mutex sınıfları tarafından sağlanan özel erişim denetimine ek olarak, paylaşılan mutex sınıfları özel olmayan erişim için birden çok iş parçacığı tarafından paylaşılan sahiplik de sağlar. Paylaşılan mutex'ler, yarış durumuna neden olmadan birkaç iş parçacığı tarafından okunabilen kaynakları denetlemek için kullanılabilir, ancak yalnızca tek bir iş parçacığı tarafından yazılması gerekir.

Üst bilgi <shared_mutex> , paylaşılan mutex desteği için sınıfları shared_mutex ve shared_timed_mutex, sınıf şablonunu shared_lockve şablon işlevini swap tanımlar.

Sözdizimi

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

Açıklamalar

sınıfının shared_mutex bir örneği, bir kapsam içindeki bir mutex'in paylaşılan sahipliğini denetleyan bir tür olan paylaşılan bir mutex türüdür. Paylaşılan bir mutex türü, bir mutex türünün tüm gereksinimlerini ve paylaşılan özel olmayan sahipliği desteklemek için üyeleri karşılar.

Paylaşılan bir mutex türü , unlock_sharedve try_lock_sharedek yöntemlerini lock_shareddestekler:

• yöntemi, lock_shared iş parçacığı mutex'in paylaşılan sahipliğini elde edene kadar çağıran iş parçacığını engeller.

• yöntemi, unlock_shared çağıran iş parçacığı tarafından tutulan mutex'in paylaşılan sahipliğini serbest bırakır.

• yöntemi, try_lock_shared engelleme olmadan mutex'in paylaşılan sahipliğini almaya çalışır. Dönüş türü olarak bool dönüştürülebilir ve true yöntemin sahiplik elde edip etmemesidir, ancak tersidir false.

sınıfı shared_timed_mutex , hem paylaşılan bir mutex türünün hem de zamanlanmış bir mutex türünün gereksinimlerini karşılayan bir tür olan paylaşılan bir zamanlanmış mutex türüdür.

Paylaşılan zamanlanmış mutex türü ek yöntemleri try_lock_shared_for ve try_lock_shared_untildestekler:

• yöntemi, try_lock_shared_for parametresi tarafından belirtilen süre geçene kadar mutex'in paylaşılan sahipliğini almayı dener. Süre pozitif değilse, yöntemi ile try_lock_sharedeşdeğerdir. Yöntem, paylaşılan sahiplik alınmadığı sürece belirtilen süre içinde döndürülmüyor. Dönüş değeri, true yöntemin sahiplik elde ettiği, ancak aksi durumda falseolduğudur.

• yöntemi, try_lock_shared_until belirtilen mutlak süre geçene kadar mutex'in paylaşılan sahipliğini elde etmeye çalışır. Belirtilen süre zaten geçtiyse, yöntemi ile try_lock_sharedeşdeğerdir. Yöntem, paylaşılan sahiplik alınmadığı sürece belirtilen süreden önce döndürülmüyor. Dönüş değeri, true yöntemin sahiplik elde ettiği, ancak aksi durumda falseolduğudur.

shared_lock Sınıf şablonu, zamanlanmış kilitleme ve sahipliğin paylaşılan bir mutex'e aktarılması desteğini genişletir. Muteksin sahipliği, inşaat sırasında veya sonrasında elde edilebilir ve başka bir shared_lock nesneye aktarılabilir. Türdeki shared_lock nesneler taşınabilir, ancak kopyalanamaz.

Sınıflar

shared_mutex Sınıfı

Sınıfı shared_mutex , paylaşılan sahiplik semantiğine sahip özyinelemeli olmayan bir mutex uygular.

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 Sınıfı

Sınıfı shared_timed_mutex , zamanlanmış bir mutex türünün gereksinimlerini karşılayan paylaşılan sahiplik semantiğine sahip özyinelemeli olmayan bir mutex uygular.

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 Sınıfı

Sınıf şablonu shared_lock , bir kapsam içindeki paylaşılan bir mutex nesnesinin paylaşılan sahipliğini denetler. Şablon parametresi paylaşılan bir mutex türü olmalıdır.

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

İşlevler

swap

shared_lock Nesneleri değiştirir.

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

İki shared_lock nesnenin içeriğini değiştirir. etkili bir şekilde ile x.swap(y)aynıdır.

Gereksinimler

Üst Bilgi:<shared_mutex>

Ad alanı: std

Ayrıca bkz.

Üst Bilgi Dosyaları Başvurusu
<mutex>