std:: shared_mutex

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

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

• exclusive - 仅有一个线程可以拥有该互斥锁。

若某一线程已获取 独占 锁（通过 lock 、 try_lock ），则其他线程均无法获取该锁（包括 共享 锁）。

若某一线程已获取 共享 锁（通过 lock_shared 、 try_lock_shared ），则其他线程无法获取 独占 锁，但仍可获取 共享 锁。

仅当任何线程都未获得 独占 锁时， 共享 锁才能被多个线程获取。

在同一线程内，只能同时获取一个锁（ 共享 或 独占 ）。

共享互斥锁在以下场景中特别有用：当共享数据可以被任意数量的线程同时安全读取，但线程仅能在没有其他线程同时读取或写入时才能写入相同数据。

shared_mutex 类满足 SharedMutex 与 StandardLayoutType 的所有要求。

成员类型

成员函数

示例

#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

参见