`<shared_mutex>`

Мақала
06/16/2023

Заголовок <shared_mutex> предоставляет примитивы синхронизации для защиты общих данных, доступ к которым может осуществляться несколькими потоками. Помимо монопольного доступа, предоставляемого классами mutex, классы shared mutex также предоставляют возможность совместного владения из нескольких потоков для неисключительного доступа. Общие мьютексы можно использовать для управления ресурсами, которые могут считываться несколькими потоками без возникновения состязания, однако должны записываться строго одним потоком.

Заголовок <shared_mutex> определяет классы shared_mutex и shared_timed_mutexшаблон класса shared_lock, а также функцию swap шаблона для поддержки общих мьютексов.

Классы	Description
Класс shared_mutex	Тип общего мьютекса, который может быть заблокирован одним агентом или совместно использоваться несколькими агентами с неисключительным доступом.
Класс shared_timed_mutex	Тип общего мьютекса с ограничением по времени, который может быть заблокирован одним агентом или совместно использоваться несколькими агентами с неисключительным доступом.
Класс shared_lock	Шаблон класса, который упаковывает общий мьютекс для поддержки операций блокировки времени и неисключающего общего доступа несколькими агентами.

Функции	Description
swap	Меняет местами содержимое общих объектов мьютекса, на которые ссылаются параметры функции.

Синтаксис

C++

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

Замечания

Экземпляр класса shared_mutex — это тип shared mutex, то есть тип, контролирующий совместное владение мьютексом внутри области. Тип общего мьютекса отвечает всем требованиям типа мьютекса и членов для поддержки общего неисключительного владения.

Тип общего мьютекса поддерживает дополнительные методы lock_shared, unlock_shared и try_lock_shared:

Метод lock_shared блокирует вызывающий поток до тех пор, пока этот поток не получит права совместного владения мьютексом.
Метод unlock_shared выпускает права совместного владения мьютексом, который содержится в вызывающем потоке.
Метод try_lock_shared пытается получить совместное владение мьютексом без блокировки. Его возвращаемое значение можно преобразовать в bool и оно является true, если метод получает права владения; в противном случае — false.

Класс shared_timed_mutex является типом общего мьютекса с ограничением по времени — типом, который соответствует требованиям типа общего мьютекса и типа мьютекса с ограничением по времени.

Тип общего мьютекса с ограничением по времени поддерживает дополнительные методы try_lock_shared_for и try_lock_shared_until:

Метод try_lock_shared_for пытается получить совместное владение мьютексом до тех пор, пока не истечет период, заданный параметром. Если период не положительный, метод равен значению try_lock_shared. Этот метод не возвращает значение в течение заданного периода, если не получено совместное владение. Он возвращает значение true, если метод получает владение; в противном случае — значение false.
Метод try_lock_shared_until пытается получить совместное владение мьютексом до тех пор, пока указанное абсолютное время не истечет. Если указанное время уже истекло, метод эквивалентен try_lock_shared. Этот метод не возвращает значение до указанного времени, если не получено совместное владение. Он возвращает значение true, если метод получает владение; в противном случае — значение false.

Шаблон shared_lock класса расширяет поддержку блокировки и передачи владения в общий мьютекс. Владение мьютексом может быть получено на этапе создания или после и может быть передано другому объекту shared_lock. Объекты типа shared_lock можно переместить, но не копировать.

Ескерту

Начиная с Visual Studio 2015, типы синхронизации стандартной библиотеки C++ основаны на примитивах синхронизации Windows и больше не используют ConcRT (за исключением случаев, когда целевая платформа — Windows XP). Типы, определенные в ней <shared_mutex> , не должны использоваться с типами или функциями ConcRT.

Классы

Класс shared_mutex

Класс shared_mutex реализует нерекурсивный мьютекс с семантикой совместного владения.

C++

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

Класс shared_timed_mutex реализует нерекурсивный мьютекс с семантикой совместного владения, который соответствует требованиям типа мьютекса с ограничением по времени.

C++

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

Шаблон shared_lock класса управляет общим владением общего объекта мьютекса в области. Параметр шаблона должен быть типом shared mutex.

C++

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

Функции

swap

Меняет местами объекты shared_lock.

C++

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

Меняет местами содержимое объектов shared_lock. Фактически совпадает с x.swap(y).

Требования

Заголовок:<shared_mutex>

Пространство имен: std

См. также

Справочник по файлам заголовков
<mutex>

Бөлісу құралы: