命名空间
变体
操作

std::shared_mutex

来自 cppreference.com
< 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 中已弃用)
内存排序
原子操作的自由函数
原子标志的自由函数
 
 
在头文件中定义 <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置于休眠状态并唤醒thread2thread2显然有足够的时间一次运行所有三个循环迭代。回到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

[编辑] 另请参阅

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