【C++并发编程】（十一）读写锁

（十一）读写锁

读写锁是一种同步机制，它允许多个线程同时以共享模式（读模式）访问共享资源，从而提高了并发读取的效率；然而，在任何一个线程需要独占访问（写模式）以修改共享资源时，它将阻止其他所有线程（无论是读模式还是写模式）访问该资源，以确保数据的一致性和完整性。或者说，读写锁分为读锁和写锁：

• 读锁：这种锁允许多个线程同时持有，使得这些线程能够并发地读取共享资源。只要没有线程持有写锁，读锁就可以被多个线程同时获取。
• 写锁：这种锁是独占的，即一次只能被一个线程持有。当线程持有写锁时，它可以修改共享资源，而其他所有尝试获取读锁或写锁的线程都将被阻塞，直到写锁被释放。这确保了在写入操作进行时，不会有其他线程（无论是读还是写）干扰，从而保护了数据的一致性。

C++17引入的 std::shared_mutex 实现了一种机制，允许同一资源有两种不同的访问权限：共享访问（读）和独占访问（写），常与以下锁管理器配合使用实现读写锁：

• std::shared_lock：在读写锁中用于管理读锁。
• std::unique_lock：在读写锁中用于管理写锁。

示例代码：

#include <iostream>
#include <thread>
#include <shared_mutex>
#include <vector>
#include <chrono>
#include <mutex>  

// 读写锁类
class ReadWriteLockExample {
private:
    int data;   // 共享数据
    std::shared_mutex rw_mutex;  // 读写锁
    int read_count;  // 读操作计数器
    int write_count; // 写操作计数器

public:
    ReadWriteLockExample() : data(0), read_count(0), write_count(0) {}

    // 读操作
    void read() {
        {
            std::shared_lock<std::shared_mutex> lock(rw_mutex); // 读锁
            ++read_count;
            std::cout << "Read #" << read_count << ": " << data << std::endl;
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟读操作耗时
    }

    // 写操作
    void write(int value) {
        {
            std::unique_lock<std::shared_mutex> lock(rw_mutex);  // 写锁
            ++write_count;
            data = value;
            std::cout << "Written #" << write_count << ": " << data << std::endl;
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟写操作耗时
    }
};
// 循环读取数据
void reader(ReadWriteLockExample& example) {
    for (int i = 0; i < 5; ++i) {
        example.read();
    }
}

// 循环写入数据
void writer(ReadWriteLockExample& example, int value) {
    for (int i = 0; i < 5; ++i) {
        example.write(value + i);
    }
}

int main() {
    ReadWriteLockExample example;

    std::vector<std::thread> threads;
    // 启动多个读线程
    for (int i = 0; i < 3; ++i) {
        threads.push_back(std::thread(reader, std::ref(example)));
    }
    // 启动一个写线程
    threads.push_back(std::thread(writer, std::ref(example), 10));

    for (auto& t : threads) {
        t.join();
    }

    return 0;
}

Read #Read #3: 0   // 同时读取
Read #3: 0
3: 0
Written #1: 10
Read #Read #5: 10Read #55: 
10
: 10
Written #2: 11
Read #6: 11
Read #Read #77: : 1111

Written #3: 12
Read #8: 12
Read #9: 12
Read #10: 12
Written #4: 13
Read #11: 13
Read #Read #1313: : 1313

Written #5: 14