Namespaces
Variants

std:: shared_timed_mutex

From zh.cppreference.net
Concurrency support library
Threads
(C++11)
(C++20)
this_thread namespace
(C++11)
(C++11)
Cooperative cancellation
Mutual exclusion
shared_timed_mutex
(C++14)
Generic lock management
Condition variables
(C++11)
Semaphores
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
Safe reclamation
Hazard pointers
Atomic types
(C++11)
(C++20)
Initialization of atomic types
(C++11) (deprecated in C++20)
(C++11) (deprecated in C++20)
Memory ordering
(C++11) (deprecated in C++26)
Free functions for atomic operations
Free functions for atomic flags
定义于头文件 <shared_mutex>
class shared_timed_mutex ;
(C++14 起)

shared_timed_mutex 类是一种同步原语,可用于保护共享数据不被多个线程同时访问。与其他支持独占访问的互斥类型不同, shared_timed_mutex 具有两个访问级别:

  • exclusive - 仅有一个线程可以拥有该互斥锁。
  • shared - 多个线程可以共享同一互斥量的所有权。

共享互斥锁通常用于多个读取器可以同时访问同一资源而不会导致数据竞争,但仅允许一个写入器进行操作的情况。

与 timed_mutex 类似, shared_timed_mutex 提供了通过 try_lock_for() 、 try_lock_until() 、 try_lock_shared_for() 、 try_lock_shared_until() 成员函数以超时方式尝试获取 shared_timed_mutex 所有权的能力。

shared_timed_mutex 类满足 SharedTimedMutex 与 StandardLayoutType 的所有要求。

目录

成员函数

构造互斥锁
(公开成员函数)
销毁互斥锁
(公开成员函数)
operator=
[deleted]
不可复制赋值
(公开成员函数)
独占锁定
锁定互斥锁,若互斥锁不可用则阻塞
(公开成员函数)
尝试锁定互斥锁,若互斥锁不可用则立即返回
(公开成员函数)
尝试锁定互斥锁,若互斥锁在指定的超时时间内
持续不可用则返回
(公开成员函数)
尝试锁定互斥锁,若互斥锁持续不可用直至
到达指定时间点则返回
(公开成员函数)
解锁互斥锁
(公开成员函数)
共享锁定
以共享所有权锁定互斥锁,若互斥锁不可用则阻塞
(公开成员函数)
尝试以共享所有权锁定互斥锁,若互斥锁不可用则立即返回
(公开成员函数)
尝试以共享所有权锁定互斥锁,若互斥锁在指定的超时时间内
持续不可用则返回
(公开成员函数)
尝试以共享所有权锁定互斥锁,若互斥锁持续不可用直至
到达指定时间点则返回
(公开成员函数)
解锁互斥锁(共享所有权)
(公开成员函数)

注释

功能测试 宏 值 标准 功能特性
__cpp_lib_shared_timed_mutex 201402L (C++14) std::shared_timed_mutex

示例

一个用于持有可支持多读者但仅允许单写者资源的类的复制赋值运算符。

#include <mutex>
#include <shared_mutex>
class R
{
    mutable std::shared_timed_mutex mut;
    /* data */
public:
    R& operator=(const R& other)
    {
        // requires exclusive ownership to write to *this
        std::unique_lock<std::shared_timed_mutex> lhs(mut, std::defer_lock);
        // requires shared ownership to read from other
        std::shared_lock<std::shared_timed_mutex> rhs(other.mut, std::defer_lock);
        std::lock(lhs, rhs);
        /* assign data */
        return *this;
    }
};
int main()
{
    R r;
}