C++ std::shared_mutex读写锁的使用

C++11中引入的 std::shared_mutex 是一种读写锁，可以在多个线程对同一个数据进行读写的情况下实现线程安全。shared_mutex允许多个线程同时进入读共享区，但只允许一个线程进入写互斥区。

如何使用 shared_mutex

使用 shared_mutex 需要注意以下几点：

1.定义 shared_mutex 对象

2.读共享区，需要使用 shared_lock 对象，调用 lock_shared 函数加锁。

3.写互斥区，需要使用 unique_lock 对象，调用 lock 函数加锁。

4.操作完成后，调用 unlock 函数释放锁。

以下是示例：

#include <iostream>
#include <thread>
#include <mutex>

std::shared_mutex mtx;
int count = 0;

// 读数据
void read_func()
{
    std::cout << "start read_func" << std::endl;
    std::shared_lock<std::shared_mutex> lock(mtx); // 读共享锁加锁
    std::cout << "count = " << count << std::endl;
}

// 写数据
void write_func()
{
    std::cout << "start write_func" << std::endl;
    std::unique_lock<std::shared_mutex> lock(mtx); // 写互斥锁加锁
    count++;
    std::cout << "count = " << count << std::endl;
}

int main()
{
    // 同时启动10个读线程和1个写线程
    std::thread write_thread(write_func);
    std::thread read_threads[10];
    for (int i = 0; i < 10; ++i)
    {
        read_threads[i] = std::thread(read_func);
    }

    write_thread.join();
    for (int i = 0; i < 10; ++i)
    {
        read_threads[i].join();
    }

    return 0;
}

在上面的示例中，我们定义了一个 shared_mutex 对象 mtx,一个全局变量 count。write_func 用于修改 count，read_func 用于读取 count。在 main 函数中，我们启动了一个写线程 write_thread 和 10个读线程 read_threads。read_func 和 write_func 都调用了 std::unique_lock 或 std::shared_lock 的构造函数，并释放了锁。在实际使用中，可以根据具体情况选择是使用 std::unique_lock 还是 std::shared_lock。

下面我们再看一个示例：

#include <iostream>
#include <thread>
#include <shared_mutex>

std::shared_mutex char_mtx;
std::shared_mutex int_mtx;
char c = 'A';
int n = 0;

void read_char()
{
    std::shared_lock<std::shared_mutex> lock(char_mtx);
    std::cout << "Char read: " << c << std::endl;
}

void read_int()
{
    std::shared_lock<std::shared_mutex> lock(int_mtx);
    std::cout << "Int read: " << n << std::endl;
}

void write_char()
{
    std::unique_lock<std::shared_mutex> lock(char_mtx);
    ++c;
    std::cout << "Char write: " << c << std::endl;
}

void write_int()
{
    std::unique_lock<std::shared_mutex> lock(int_mtx);
    ++n;
    std::cout << "Int write: " << n << std::endl;
}

int main()
{
    std::thread t1(read_char);   // 读char
    std::thread t2(read_int);    // 读int
    std::thread t3(write_char);  // 写char
    std::thread t4(write_int);   // 写int
    std::thread t5(read_char);   // 读char
    std::thread t6(read_int);    // 读int

    t1.join();
    t2.join();
    t3.join();
    t4.join();
    t5.join();
    t6.join();

    return 0;
}

在这个示例中，我们使用两个 shared_mutex 变量进行读写操作，分别对应 char 类型和 int 类型的变量。通过五个线程来对这两个变量进行不同的读写操作，其中 t3 和 t4 写线程是互斥的，即不能同时写 char 和 int。其他的读线程可以同时读取 char 和 int。