c++怎么实现读写锁_c++读写锁实现方法

推荐使用C++17的std::shared_mutex实现读写锁，允许多个读线程共享访问、写线程独占访问；其通过std::shared_lock和std::unique_lock提供安全高效的并发控制，优于手动或Boost实现。

在C++中实现读写锁，核心目标是允许多个线程同时读取共享资源，但写操作必须独占访问。也就是说，读锁可以并发，写锁必须互斥且与读锁互斥。以下是几种常见的C++读写锁实现方法。

使用标准库 std::shared_mutex（C++17 及以上）

从 C++17 开始，标准库提供了 std::shared_mutex，它天然支持读写锁语义：

• 共享锁（读锁）：通过 std::shared_lock 获取，多个线程可同时持有。
• 独占锁（写锁）：通过 std::unique_lock 获取，仅一个线程可持有。

#include <shared_mutex>
#include <thread>
#include <vector>

std::shared_mutex rw_mutex;
int shared_data = 0;

void reader(int id) {
std::shared_lock lock(rw_mutex); // 获取读锁
// 读取 shared_data
}

void writer(int value) {
std::unique_lock lock(rw_mutex); // 获取写锁
shared_data = value;
}

这是最推荐的方式，简洁、安全、性能良好。

手动实现简易读写锁（基于互斥量和条件变量）

在不支持 C++17 的环境中，可以用 std::mutex 和 std::condition_variable 手动实现一个基础读写锁。

立即学习“C++免费学习笔记（深入）”；

class ReadWriteLock {
private:
std::mutex mtx;
std::condition_variable cv;
int readers = 0;
bool writing = false;

public:
void lock_read() {
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, [this] { return !writing; });
++readers;
lock.unlock();
cv.notify_all();
}

void unlock_read() {
std::lock_guard<std::mutex> lock(mtx);
–readers;
}

void lock_write() {
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, [this] { return !writing && readers == 0; });
writing = true;
}

void unlock_write() {
std::lock_guard<std::mutex> lock(mtx);
writing = false;
cv.notify_all();
}
};

说明：

• 读线程等待 writing 为 false 即可进入。
• 写线程必须等待 没有写者且读者数为0 才能进入。
• 注意唤醒所有等待线程以避免死锁或饥饿。

使用 Boost 库的 boost::shared_mutex

在 C++17 之前，Boost 提供了跨平台的解决方案：

#include <boost/thread/shared_mutex.hpp>

boost::shared_mutex boost_rw_mutex;

void reader() {
boost::shared_lock<boost::shared_mutex> lock(boost_rw_mutex);
// 读操作
}

void writer() {
boost::unique_lock<boost::shared_mutex> lock(boost_rw_mutex);
// 写操作
}

功能与 std::shared_mutex 类似，适用于老版本编译器。

性能与注意事项

读写锁适合读多写少的场景。如果写操作频繁，可能引发读者或写者饥饿。

• 标准库的 std::shared_mutex 实现通常更高效。
• 手动实现需特别注意条件变量的唤醒逻辑，避免死锁。
• 考虑是否需要公平性（如先来先服务），某些实现可能偏向读或写。

基本上就这些。优先用 C++17 的 std::shared_mutex，兼容性和性能都更好。