c++中的读写锁

读写锁是一种特殊的锁机制，允许多个线程同时读取共享数据，但在写入共享数据时，只有一个线程可以进行写操作，其他线程必须等待。

这种机制对于读多写少的场景非常有效，可以提高并发性能。以下是通过 shared_lock、unique_lock、shared_mutex 和 mutex 的解释来说明读写锁的实现和应用。

1. 基本概念

• 读锁（Shared Lock）：

  • 使用 shared_lock 加锁，允许多个线程同时持有读锁，这样它们可以并发地读取共享数据。
  • 在持有读锁的情况下，其他线程仍然可以获取读锁，但无法获取写锁。

• 写锁（Exclusive Lock）：

  • 使用 unique_lock 加锁，只有一个线程可以持有写锁。持有写锁的线程在写入数据时，其他线程无法获取任何类型的锁（无论是读锁还是写锁）。
  • 写锁的目的在于保证数据的安全性和一致性。

2. shared_mutex 与 mutex

• shared_mutex：

  • 是 C++14 引入的一个互斥体类型，专门用于支持读写锁。
    -** 它支持共享锁（通过 shared_lock）和独占锁（通过 unique_lock）**。通过这种方式，多个线程可以安全地读取数据，而在写入数据时，可以保证只有一个线程在写。

• mutex：

  • 是最基本的互斥体，提供了互斥访问共享资源的功能。
  • 使用 mutex 时，如果一个线程持有锁，其他线程都无法访问受保护的资源。

3. 示例代码

以下是一个示例，展示了如何使用 shared_mutex、shared_lock 和 unique_lock 实现一个简单的读写锁：

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

class SharedData {
private:
    int data;
    mutable std::shared_mutex mutex;

public:
    SharedData() : data(0) {}

    // 读操作
    int read() const {
        std::shared_lock<std::shared_mutex> lock(mutex); // 共享锁
        return data;
    }

    // 写操作
    void write(int value) {
        std::unique_lock<std::shared_mutex> lock(mutex); // 独占锁
        data = value;
    }
};

// 读线程函数
void reader(SharedData& shared_data, int id) {
    for (int i = 0; i < 5; ++i) {
        std::cout << "Reader " << id << " reads: " << shared_data.read() << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

// 写线程函数
void writer(SharedData& shared_data, int value) {
    for (int i = 0; i < 5; ++i) {
        shared_data.write(value);
        std::cout << "Writer writes: " << value << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(300));
        value++; // 增加写入值
    }
}

int main() {
    SharedData shared_data;

    // 创建读线程
    std::vector<std::thread> readers;
    for (int i = 0; i < 3; ++i) {
        readers.emplace_back(reader, std::ref(shared_data), i);
    }

    // 创建写线程
    std::thread writer_thread(writer, std::ref(shared_data), 0);

    // 等待线程完成
    for (auto& r : readers) {
        r.join();
    }
    writer_thread.join();

    return 0;
}

4. 解释

• 共享读取：

  • 在 read 方法中，使用 shared_lock 来加锁。这允许多个线程同时读取 data，因为它们不会阻塞彼此。

• 独占写入：

  • 在 write 方法中，使用 unique_lock 来加锁。这保证了在写入数据时，其他线程不能读取或写入。

• 线程安全：

  • 通过使用 shared_mutex，确保在读取时允许并发访问，而在写入时则独占访问，有效提高了程序的并发性能。

总结

读写锁是提高读多写少场景下性能的有效机制。通过使用 shared_mutex、shared_lock 和 unique_lock，可以实现安全的并发访问，确保数据的一致性和正确性。这种方式在多线程编程中是非常常见的，特别是在需要频繁读取而写入相对较少的应用中。