命名空间
变体
操作

std::shared_mutex

来自 cppreference.cn
< cpp‎ | thread
 
 
并发支持库
线程
(C++11)
(C++20)
this_thread 命名空间
(C++11)
(C++11)
(C++11)
协同取消
互斥
(C++11)
shared_mutex
(C++17)
通用锁管理
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
条件变量
(C++11)
信号量
门闩和屏障
(C++20)
(C++20)
期值
(C++11)
(C++11)
(C++11)
(C++11)
安全回收
(C++26)
危险指针
原子类型
(C++11)
(C++20)
原子类型的初始化
(C++11)(C++20 中已弃用)
(C++11)(C++20 中已弃用)
内存排序
(C++11)(C++26 中已弃用)
原子操作的自由函数
原子标志的自由函数
 
 
定义于头文件 <shared_mutex>
class shared_mutex;
(C++17 起)

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

  • 共享 - 多个线程可以共享同一个互斥体的所有权。
  • 独占 - 只有一个线程可以拥有互斥体。

如果一个线程获得了独占锁(通过locktry_lock),则其他任何线程都无法获得该锁(包括共享锁)。

如果一个线程获得了共享锁(通过lock_sharedtry_lock_shared),则其他任何线程都无法获得独占锁,但可以获得共享锁。

只有当没有任何线程获得独占锁时,多个线程才能获得共享锁。

在一个线程内,一次只能获取一个锁(共享独占)。

共享互斥体在以下情况下特别有用:共享数据可以被任意数量的线程同时安全读取,但只有当没有其他线程同时读取或写入时,线程才能写入相同的数据。

shared_mutex 类满足SharedMutexStandardLayoutType的所有要求。

目录

[编辑] 成员类型

成员类型 定义
native_handle_type (可选*) 实现定义[编辑]

[编辑] 成员函数

构造互斥体
(公共成员函数) [编辑]
销毁互斥体
(公共成员函数) [编辑]
operator=
[已删除]
不可复制赋值
(公共成员函数) [编辑]
独占锁定
锁定互斥体,如果互斥体不可用则阻塞
(公共成员函数) [编辑]
尝试锁定互斥体,如果互斥体不可用则返回
(公共成员函数) [编辑]
解锁互斥体
(公共成员函数) [编辑]
共享锁定
以共享所有权锁定互斥体,如果互斥体不可用则阻塞
(公共成员函数) [编辑]
尝试以共享所有权锁定互斥体,如果互斥体不可用则返回
(公共成员函数) [编辑]
解锁互斥体(共享所有权)
(公共成员函数) [编辑]
原生句柄
返回底层实现定义的原生句柄对象
(公共成员函数) [编辑]

[编辑] 示例

下面的输出是在单核机器上生成的。当 thread1 启动时,它第一次进入循环并调用 increment(),然后调用 get()。然而,在它将返回值打印到 std::cout 之前,调度程序将 thread1 置于休眠状态并唤醒 thread2,后者显然有足够的时间一次运行所有三个循环迭代。回到 thread1,仍然在第一个循环迭代中,它最终将其计数器值的本地副本(即 1)打印到 std::cout,然后运行剩余的两个循环迭代。在多核机器上,没有线程被置于休眠状态,输出更可能是升序。

#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <syncstream>
#include <thread>
 
class ThreadSafeCounter
{
public:
    ThreadSafeCounter() = default;
 
    // Multiple threads/readers can read the counter's value at the same time.
    unsigned int get() const
    {
        std::shared_lock lock(mutex_);
        return value_;
    }
 
    // Only one thread/writer can increment/write the counter's value.
    void increment()
    {
        std::unique_lock lock(mutex_);
        ++value_;
    }
 
    // Only one thread/writer can reset/write the counter's value.
    void reset()
    {
        std::unique_lock lock(mutex_);
        value_ = 0;
    }
 
private:
    mutable std::shared_mutex mutex_;
    unsigned int value_{};
};
 
int main()
{
    ThreadSafeCounter counter;
 
    auto increment_and_print = [&counter]()
    {
        for (int i{}; i != 3; ++i)
        {
            counter.increment();
            std::osyncstream(std::cout)
                << std::this_thread::get_id() << ' ' << counter.get() << '\n';
        }
    };
 
    std::thread thread1(increment_and_print);
    std::thread thread2(increment_and_print);
 
    thread1.join();
    thread2.join();
}

可能的输出

123084176803584 2
123084176803584 3
123084176803584 4
123084185655040 1
123084185655040 5
123084185655040 6

[编辑] 另请参阅

提供共享互斥设施,并实现带超时锁
(类) [编辑]
实现可移动的共享互斥量所有权包装器
(类模板) [编辑]
实现可移动的互斥体所有权包装器
(类模板) [编辑]