C++中读写锁的实现

共享互斥锁（读写锁，C++17 引入）

区分 “读操作” 和 “写操作”，允许多个线程同时读（共享模式），但写操作必须独占（独占模式），适合 “多读少写” 场景。

std::shared_mutex（C++17）/ std::shared_timed_mutex（C++14）

• 作用：提供两种锁定模式：
  • 独占模式（写锁）：同一时间只有一个线程可获取，获取后其他线程（读或写）均阻塞。
  • 共享模式（读锁）：多个线程可同时获取，获取后其他写线程阻塞，但读线程可继续获取。
• shared_timed_mutex：在 shared_mutex 基础上增加了限时获取锁的接口（try_lock_shared_for 等）。
• 实现原理：内部维护读者计数和写者状态：
  • 读锁获取：若当前无写者持有锁，读者计数加 1；若有写者，阻塞。
  • 读锁释放：读者计数减 1，当计数为 0 时，唤醒可能等待的写者。
  • 写锁获取：若当前无读者和写者，标记为 “有写者”；否则阻塞。
  • 写锁释放：清除 “有写者” 标记，唤醒所有等待的读者或一个等待的写者（公平性由实现决定）。

    #include <shared_mutex>
    #include <iostream>
    #include <thread>
    #include <vector>
    
    // 共享资源
    int shared_data = 0;
    // 读写锁（C++17）
    std::shared_mutex rw_mutex;
    
    // 读操作（共享模式）
    void read_data(int id) {
        // 获取读锁（共享模式），离开作用域自动释放
        std::shared_lock<std::shared_mutex> lock(rw_mutex);
        std::cout << "Reader " << id << " reads: " << shared_data << "\n";
    }
    
    // 写操作（独占模式）
    void write_data(int id, int value) {
        // 获取写锁（独占模式），离开作用域自动释放
        std::unique_lock<std::shared_mutex> lock(rw_mutex);
        shared_data = value;
        std::cout << "Writer " << id << " writes: " << shared_data << "\n";
    }
    
    int main() {
        std::vector<std::thread> threads;
        // 启动5个读线程
        for (int i = 0; i < 5; ++i) {
            threads.emplace_back(read_data, i);
        }
        // 启动2个写线程
        threads.emplace_back(write_data, 0, 100);
        threads.emplace_back(write_data, 1, 200);
        // 等待所有线程完成
        for (auto& t : threads) {
            t.join();
        }
        return 0;
    }