C++读写锁详解（共享互斥锁在多线程同步中的应用）

什么是读写锁？

读写锁（Read-Write Lock），也称为共享互斥锁，是一种特殊的互斥锁。它区分两种操作：

• 读操作（共享）：多个线程可以同时持有读锁，只要没有线程持有写锁。
• 写操作（独占）：写锁是排他的，一旦某个线程持有写锁，其他任何读或写操作都必须等待。

C++标准库中的读写锁

从 C++17 开始，标准库提供了 std::shared_mutex 类型，用于实现读写锁功能。在 C++14 中也有 std::shared_timed_mutex，但功能稍弱。

关键类与函数

• std::shared_mutex：提供读写锁的核心类。
• std::shared_lock<Mutex>：用于自动获取和释放共享（读）锁。
• std::unique_lock<Mutex>：用于自动获取和释放独占（写）锁。

完整示例：使用C++读写锁保护共享数据

下面是一个完整的例子，演示如何使用 std::shared_mutex 来实现线程安全的缓存读写操作：

#include <iostream>#include <thread>#include <shared_mutex>#include <vector>#include <chrono>class SafeCache {private:    mutable std::shared_mutex cache_mutex;    std::vector<int> data;public:    void write(int value) {        std::unique_lock<std::shared_mutex> lock(cache_mutex);        data.push_back(value);        std::cout << "写入: " << value << std::endl;    }    int read(size_t index) const {        std::shared_lock<std::shared_mutex> lock(cache_mutex);        if (index < data.size()) {            return data[index];        }        return -1;    }};int main() {    SafeCache cache;    // 创建多个读线程和写线程    std::vector<std::thread> threads;    // 启动两个写线程    threads.emplace_back([&cache]() {        for (int i = 0; i < 3; ++i) {            cache.write(i);            std::this_thread::sleep_for(std::chrono::milliseconds(100));        }    });    threads.emplace_back([&cache]() {        for (int i = 10; i < 13; ++i) {            cache.write(i);            std::this_thread::sleep_for(std::chrono::milliseconds(150));        }    });    // 启动三个读线程    for (int r = 0; r < 3; ++r) {        threads.emplace_back([&cache, r]() {            for (int i = 0; i < 5; ++i) {                int val = cache.read(i);                if (val != -1) {                    std::cout << "读者[" << r << "] 读取索引 "                               << i << ": " << val << std::endl;                }                std::this_thread::sleep_for(std::chrono::milliseconds(50));            }        });    }    // 等待所有线程完成    for (auto& t : threads) {        t.join();    }    return 0;}

为什么使用读写锁？

在传统的互斥锁（如 std::mutex）中，即使是多个只读操作也不能同时进行，这会降低并发性能。而 C++读写锁 允许多个读操作并发执行，从而在“读多写少”的场景下大幅提升吞吐量。

最佳实践与注意事项

• 始终使用 RAII 封装（如 std::shared_lock 和 std::unique_lock），避免手动加锁/解锁导致死锁。
• 避免在持有读锁期间调用可能阻塞的操作，以防写线程长时间饥饿。
• 读写锁适用于“读远多于写”的场景；如果读写频率接近，普通互斥锁可能更简单高效。
• 注意 std::shared_mutex 需要 C++17 或更高版本支持。

总结

通过本文，我们深入学习了 C++并发编程 中的读写锁机制。利用 std::shared_mutex，我们可以高效地实现多线程环境下的资源共享，既保证了数据一致性，又提升了系统并发性能。掌握 多线程同步 技术是编写高性能 C++ 应用的关键一步。

希望这篇教程能帮助你轻松理解并应用 C++ 读写锁！