# 标准库头文件 <shared_mutex>

< cpp‎ | header

此头文件是线程支持库的一部分。

### 类
shared_mutex (C++17) | 提供共享互斥设施 (类)
shared_timed_mutex (C++14) | 提供共享互斥设施并实现有时限锁定 (类)
shared_lock (C++14) | 实现可移动的共享互斥体所有权封装器 (类模板)
### 函数
std::swap(std::shared_lock) (C++14) | std::swap 对 `shared_lock` 的特化 (函数模板)

### 概要

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

#### 类 std::shared_mutex

    namespace std {
      class shared_mutex {
      public:
        shared_mutex();
        ~shared_mutex();

        shared_mutex(const shared_mutex&) = delete;
        shared_mutex& operator=(const shared_mutex&) = delete;

        // 排他性所有权
        void lock();                // 阻塞
        bool try_lock();
        void unlock();

        // 共享所有权
        void lock_shared();         // 阻塞
        bool try_lock_shared();
        void unlock_shared();

        using native_handle_type = /* 由实现定义 */;
        native_handle_type native_handle();
      };
    }

#### 类 std::shared_timed_mutex

    namespace std {
      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;

        // 排他性所有权
        void lock();                // 阻塞
        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();

        // 共享所有权
        void lock_shared();         // 阻塞
        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();
      };
    }

#### 类模板 std::shared_lock

    namespace std {
      template<class Mutex>
      class shared_lock {
      public:
        using mutex_type = Mutex;

        // 构造/复制/析构
        shared_lock() noexcept;
        explicit shared_lock(mutex_type& m);        // 阻塞
        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(const shared_lock&) = delete;
        shared_lock& operator=(const shared_lock&) = delete;

        shared_lock(shared_lock&& u) noexcept;
        shared_lock& operator=(shared_lock&& u) noexcept;

        // 锁定
        void lock();                                // 阻塞
        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();

        // 修改器
        void swap(shared_lock& u) noexcept;
        mutex_type* release() noexcept;

        // 观察器
        bool owns_lock() const noexcept;
        explicit operator bool () const noexcept;
        mutex_type* mutex() const noexcept;

      private:
        mutex_type* pm;                             // 仅用于阐释
        bool owns;                                  // 仅用于阐释
      };

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