C++怎么实现一个读写锁_C++并发编程与读写锁实现

答案是使用std::shared_mutex实现读写锁，允许多个读线程共享访问、写线程独占访问，提升读多写少场景的并发性能；C++17中通过lock_shared()和lock()分别获取读锁和写锁，配合std::shared_lock和std::unique_lock实现RAII管理，避免资源泄漏；若兼容C++11，则可用mutex与condition_variable手动实现读写状态控制，确保读时不写、写时互斥。

在C++中实现读写锁（Reader-Writer Lock），核心目标是允许多个读线程同时访问共享资源，但写线程独占访问。这种机制适用于“读多写少”的场景，能显著提升并发性能。

使用标准库的 shared_mutex 实现读写锁

C++17 起提供了 std::shared_mutex，天然支持读写锁语义：

• 共享所有权（读锁）：多个线程可同时获得共享锁（.lock_shared()）
• 独占所有权（写锁）：仅一个线程可获得独占锁（.lock()）

#include 
#include 
#include 
#include 

std::shared_mutex rw_mutex;
int data = 0;

void reader(int id) {
    rw_mutex.lock_shared();
    std::cout << "Reader " << id << " reads data: " << data << "\n";
    rw_mutex.unlock_shared();
}

void writer(int id) {
    rw_mutex.lock();
    data += id;
    std::cout << "Writer " << id << " writes data: " << data << "\n";
    rw_mutex.unlock();
}

int main() {
    std::vector threads;
    for (int i = 0; i < 3; ++i) {
        threads.emplace_back(reader, i);
    }
    threads.emplace_back(writer, 10);
    threads.emplace_back(reader, 99);

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

输出中，多个读线程可能同时执行，而写线程会阻塞所有读操作。

手动实现简易读写锁（C++11 兼容）

若不能使用 C++17，可用互斥量和条件变量模拟读写锁逻辑。

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

基本思路：

笔头写作

AI为论文写作赋能，协助你从0到1。

下载

• 用 std::mutex 保护读写状态
• 用 std::condition_variable 协调读写线程
• 维护当前活跃读线程数和是否正在写

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

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

    void unlock_read() {
        std::lock_guard lock(mtx);
        readers--;
        if (readers == 0) cv.notify_all();
    }

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

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

使用时需注意避免死锁，比如不要在持有读锁时尝试获取写锁。

RAII 封装提升安全性

为避免忘记解锁，应使用 RAII 包装器：

• std::shared_lock<:shared_mutex>：管理共享锁（读）
• std::unique_lock<:shared_mutex>：管理独占锁（写）

std::shared_mutex rw_mutex;

void safe_read() {
    std::shared_lock lock(rw_mutex);
    // 自动加共享锁，作用域结束自动释放
    std::cout << "Reading: " << data << "\n";
}

void safe_write(int val) {
    std::unique_lock lock(rw_mutex);
    data = val;
}

RAII 是 C++ 并发编程的最佳实践，极大降低资源管理错误风险。

基本上就这些。优先使用 std::shared_mutex + std::shared_lock/unique_lock，简洁高效。若需兼容旧标准，可手写基于 condition_variable 的版本，但务必测试竞争边界情况。