<shared_mutex>

  • Artikel

Header <shared_mutex> menyediakan primitif sinkronisasi untuk perlindungan data bersama yang dapat diakses oleh beberapa utas. Selain kontrol akses eksklusif yang disediakan oleh kelas mutex, kelas mutex bersama juga memungkinkan kepemilikan bersama oleh beberapa utas untuk akses non-eksklusif. Mutex bersama dapat digunakan untuk mengontrol sumber daya yang dapat dibaca oleh beberapa utas tanpa menyebabkan kondisi balapan, tetapi harus ditulis secara eksklusif oleh satu utas.

Header <shared_mutex> menentukan kelas shared_mutex dan shared_timed_mutex, templat shared_lockkelas , dan fungsi swap templat untuk dukungan mutex bersama.

Kelas Deskripsi
Kelas shared_mutex Jenis mutex bersama yang dapat dikunci secara eksklusif oleh satu agen atau dibagikan secara non-eksklusif oleh beberapa agen.
Kelas shared_timed_mutex Jenis mutex berwaktu bersama yang dapat dikunci secara eksklusif oleh satu agen atau dibagikan secara non-eksklusif oleh beberapa agen.
Kelas shared_lock Templat kelas yang membungkus mutex bersama untuk mendukung operasi penguncian waktu dan berbagi non-eksklusif oleh beberapa agen.
Fungsi Deskripsi
tukar Menukar konten objek mutex bersama yang dirujuk oleh parameter fungsi.

Sintaks

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

Keterangan

Instans kelas shared_mutex adalah jenis mutex bersama, jenis yang mengontrol kepemilikan bersama muteks dalam cakupan. Jenis mutex bersama memenuhi semua persyaratan jenis mutex, serta anggota untuk mendukung kepemilikan non-eksklusif bersama.

Jenis mutex bersama mendukung metode lock_sharedtambahan , , unlock_shareddan try_lock_shared:

  • Metode ini lock_shared memblokir utas panggilan hingga utas mendapatkan kepemilikan bersama atas mutex.

  • Metode ini unlock_shared merilis kepemilikan bersama dari mutex yang dipegang oleh utas panggilan.

  • Metode ini try_lock_shared mencoba mendapatkan kepemilikan bersama atas mutex tanpa memblokir. Jenis pengembaliannya dapat dikonversi ke bool dan adalah true jika metode mendapatkan kepemilikan, tetapi sebaliknya false.

Kelas shared_timed_mutex ini adalah jenis mutex berwakti bersama, jenis yang memenuhi persyaratan jenis mutex bersama dan jenis muteks berwak waktu.

Jenis muteks waktu bersama mendukung metode try_lock_shared_for tambahan dan try_lock_shared_until:

  • Metode ini try_lock_shared_for mencoba untuk mendapatkan kepemilikan bersama atas mutex sampai durasi yang ditentukan oleh parameter telah berlalu. Jika durasi tidak positif, metode ini setara dengan try_lock_shared. Metode ini tidak kembali dalam durasi yang ditentukan kecuali kepemilikan bersama diperoleh. Nilai pengembaliannya adalah true jika metode memperoleh kepemilikan, tetapi sebaliknya false.

  • Metode ini try_lock_shared_until mencoba untuk mendapatkan kepemilikan bersama atas mutex sampai waktu absolut yang ditentukan telah berlalu. Jika waktu yang ditentukan telah berlalu, metode ini setara dengan try_lock_shared. Metode ini tidak kembali sebelum waktu yang ditentukan kecuali kepemilikan bersama diperoleh. Nilai pengembaliannya adalah true jika metode memperoleh kepemilikan, tetapi sebaliknya false.

shared_lock Templat kelas memperluas dukungan untuk penguncian waktu dan transfer kepemilikan ke mutex bersama. Kepemilikan mutex dapat diperoleh pada atau setelah konstruksi, dan dapat ditransfer ke objek lain shared_lock . Objek bertipe shared_lock dapat dipindahkan, tetapi tidak disalin.

Peringatan

Dimulai di Visual Studio 2015, jenis sinkronisasi Pustaka Standar C++ didasarkan pada primitif sinkronisasi Windows dan tidak lagi menggunakan ConcRT (kecuali ketika platform target adalah Windows XP). Jenis yang ditentukan di <shared_mutex> tidak boleh digunakan dengan jenis atau fungsi ConcRT apa pun.

Kelas

Kelas shared_mutex

Kelas shared_mutex mengimplementasikan mutex non-rekursif dengan semantik kepemilikan bersama.

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

Kelas shared_timed_mutex

Kelas shared_timed_mutex mengimplementasikan mutex non-rekursif dengan semantik kepemilikan bersama yang memenuhi persyaratan jenis muteks waktu.

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

Kelas shared_lock

Templat kelas shared_lock mengontrol kepemilikan bersama objek mutex bersama dalam cakupan. Parameter templat harus berupa jenis mutex bersama.

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

Fungsi

pertukaran

Menukar shared_lock objek.

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

Menukar konten dua shared_lock objek. Secara efektif sama x.swap(y)dengan .

Persyaratan

Header:<shared_mutex>

Namespace: std

Baca juga

Referensi File Header
<mutex>