std::shared_mutex与std::mutex的不同适用场合

std::shared_mutex与std::mutex的不同适用场合_sharedmutex和mutex-优快云博客

std::shared_mutex 与 std::mutex 的不同点
锁定模式：

std::shared_mutex 支持两种锁定模式：共享锁（shared lock）和独占锁（exclusive lock）。
共享锁（shared lock）：多个线程可以同时持有共享锁（通常用于读操作）。
独占锁（exclusive lock）：只有一个线程可以持有独占锁（通常用于写操作）。
std::mutex 只支持独占锁（exclusive lock），即同一时间只能有一个线程持有锁。
适用的场景：

std::shared_mutex 特别适用于读多写少的场景，例如缓存、配置管理等。
std::mutex 适用于一般的互斥场景，读写操作不频繁，或者读写操作都需要独占访问的情况。
适用场合
std::shared_mutex 适用场合：

读多写少：当多个线程主要进行读操作，而写操作较少时，使用std::shared_mutex可以提高并发性能。
并发读：在需要多个线程同时读取共享数据的场景中，std::shared_mutex允许多个线程同时持有共享锁，避免了不必要的锁争用。
std::mutex 适用场合：

读写频繁：当读写操作都很频繁，且读操作不需要并发访问时，使用std::mutex可以确保数据的一致性。
独占访问：当需要确保数据在任何时候都只有一个线程访问时，使用std::mutex可以简单直接地实现这一点。
示例代码
以下是使用std::shared_mutex的示例代码，展示了如何在读多写少的场景中使用共享锁和独占锁：

#include <iostream>
#include <shared_mutex>
#include <thread>
#include <vector>
 
class SharedData {
public:
    void read() const {
        std::shared_lock<std::shared_mutex> lock(mtx); // 共享锁
        std::cout << "Reading data: " << data << std::endl;
    }
 
    void write(int newData) {
        std::unique_lock<std::shared_mutex> lock(mtx); // 独占锁
        data = newData;
        std::cout << "Writing data: " << data << std::endl;
    }
 
private:
    mutable std::shared_mutex mtx; // 可变的共享互斥锁
    int data = 0;
};
 
void reader(SharedData& sharedData, int id) {
    for (int i = 0; i < 5; ++i) {
        sharedData.read();
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}
 
void writer(SharedData& sharedData, int id) {
    for (int i = 0; i < 2; ++i) {
        int newData = id * 10 + i;
        sharedData.write(newData);
        std::this_thread::sleep_for(std::chrono::milliseconds(200));
    }
}
 
int main() {
    SharedData sharedData;
    std::vector<std::thread> threads;
 
    // 创建5个读线程
    for (int i = 0; i < 5; ++i) {
        threads.push_back(std::thread(reader, std::ref(sharedData), i));
    }
 
    // 创建2个写线程
    for (int i = 0; i < 2; ++i) {
        threads.push_back(std::thread(writer, std::ref(sharedData), i));
    }
 
    // 等待所有线程完成
    for (auto& t : threads) {
        t.join();
    }
 
    return 0;
}

总结
std::shared_mutex 提供了比 std::mutex 更灵活的同步机制，特别适用于读多写少的场景。通过使用共享锁和独占锁，std::shared_mutex 允许多个线程同时读取共享数据，同时确保写操作的独占性，从而提高了并发性能。在设计和实现多线程程序时，根据具体的应用场景选择合适的同步机制，可以有效提高程序的性能和可维护性。