std::shared_mutex 是 “读写锁（RW lock）” 的 C++ 标准实现：
读多写少 的场景下，它能显著提高并发度。

---

1️⃣ 它是什么（一句话）

shared_mutex 允许多个线程同时“读”，但“写”必须独占。

• 共享锁（shared lock）：给读者用，可并发

• 独占锁（unique/exclusive lock）：给写者用，互斥

---

2️⃣ 基本接口与对应 RAII

锁的两种模式

std::shared_mutex m;

// 写（独占）
m.lock();
m.unlock();

// 读（共享）
m.lock_shared();
m.unlock_shared();

推荐的 RAII 写法

// 写
std::unique_lock<std::shared_mutex> w(m);

// 读
std::shared_lock<std::shared_mutex> r(m);

shared_lock 专门用于“读锁”，语义更清晰。

---

3️⃣ 最典型的使用示例

读多写少的缓存

std::shared_mutex m;
std::unordered_map<int, int> cache;

// 读
int get(int k) {
    std::shared_lock<std::shared_mutex> r(m);
    auto it = cache.find(k);
    return it == cache.end() ? -1 : it->second;
}

// 写
void put(int k, int v) {
    std::unique_lock<std::shared_mutex> w(m);
    cache[k] = v;
}

效果：

• 多个 get() 可并发

• put() 会 阻塞所有读写

---

4️⃣ 和 mutex 的核心区别

维度	mutex	shared_mutex
并发读	❌	✅
写独占	✅	✅
适合场景	写多 / 临界区小	读多写少
成本	低	更高

如果读写比例不明显，mutex 往往更快。

---

5️⃣ 常见进阶用法

✅ 尝试锁（非阻塞）

std::shared_lock<std::shared_mutex> r(m, std::try_to_lock);
if (!r.owns_lock()) {
    // 拿不到读锁
}

✅ 限时（C++14/17，取决于实现）

std::shared_timed_mutex m; // C++14
std::shared_lock<std::shared_timed_mutex> r(m, std::defer_lock);
if (r.try_lock_for(10ms)) { /* ... */ }

C++17 的 shared_mutex 不保证 timed 接口；要 timed 用 shared_timed_mutex（或 C++20 实现细节）。

---

6️⃣ 一个重要限制：不能“读锁升级为写锁”

❌ 这样会死锁：

std::shared_lock<std::shared_mutex> r(m);
// ...
std::unique_lock<std::shared_mutex> w(m); // ❌

原因：

• 你还持有读锁

• 写锁需要“没有任何读者”

正确做法（释放再重试）

{
    std::shared_lock<std::shared_mutex> r(m);
    // 读
}
// 释放读锁
{
    std::unique_lock<std::shared_mutex> w(m);
    // 写
}

如果你必须支持升级，通常需要更复杂的设计（版本号/双检、CAS、或外部协调）。

---

7️⃣ 公平性与饥饿问题（工程要点）

• 标准不保证公平性

• 某些实现：

  • 读者可能饿死写者

  • 或写者优先，读被延迟

建议：

• 写操作要尽量短

• 避免在读锁内做慢 IO

• 高写压力下，考虑退回 mutex

---

8️⃣ 什么时候该用 / 不该用

✅ 该用

• 配置表、路由表、元数据索引

• 热路径以读为主（如 90%+ 读）

❌ 不该用

• 写很多或读写比例不确定

• 临界区很小（mutex 更快）

• 需要频繁“读→写升级”

---

9️⃣ 一句话总结（记住这个）

shared_mutex = 读共享、写独占；
读多写少才有价值，用前先看比例。

一句话先给你：

std::shared_mutex 是“锁本体（资源）”，
std::shared_lock 是“持有共享锁的 RAII 管理器（工具）”。

下面按「角色 / 行为 / 用法」把它们的关系讲清楚。

---

1️⃣ 各自是什么角色？

🔒 shared_mutex

• 同步原语（mutex 本体）

• 提供两种加锁模式：

  • 独占锁：lock() / unlock()（写）

  • 共享锁：lock_shared() / unlock_shared()（读）

它本身不管理生命周期，只是“能锁 / 能解”。

---

🧩 shared_lock

• RAII 封装器

• 专门用来持有 shared_mutex 的“共享锁（读锁）”

• 负责：

  • 构造时加 lock_shared()

  • 析构时 unlock_shared()

std::shared_mutex m;
std::shared_lock<std::shared_mutex> r(m); // lock_shared
// ...
// 析构时 unlock_shared

---

2️⃣ 它们之间的直接关系

shared_lock 只能用于支持 lock_shared() 的 mutex 类型
（如 shared_mutex、shared_timed_mutex）

换句话说：

• shared_mutex = 能力提供者

• shared_lock = 使用该能力的 RAII 工具

---

3️⃣ 对照关系表（很直观）

操作意图	直接 API	RAII 推荐
读锁	m.lock_shared()	std::shared_lock<shared_mutex>
写锁	m.lock()	std::unique_lock<shared_mutex>
自动释放	❌	✅
异常安全	❌	✅

---

4️⃣ 为什么要分成两个类型？

原因 1：职责分离

• shared_mutex：负责“能不能锁”

• shared_lock：负责“什么时候锁 / 解锁”

这和：

• mutex + lock_guard

• mutex + unique_lock

是一模一样的设计思想。

---

原因 2：语义更清晰（工程价值很大）

void read() {
    std::shared_lock<std::shared_mutex> r(m);
    // 一看就知道：这是读路径
}

void write() {
    std::unique_lock<std::shared_mutex> w(m);
    // 一看就知道：这是写路径
}

👉 比看到 lock() / unlock() 清晰得多。

---

5️⃣ 常见误区（非常重要）

❌ 误区 1：shared_lock ≈ unique_lock

不对：

• unique_lock<shared_mutex> → 写锁

• shared_lock<shared_mutex> → 读锁

两者语义完全不同。

---

❌ 误区 2：shared_lock 能“升级”为写锁

不行：

std::shared_lock<std::shared_mutex> r(m);
// ...
std::unique_lock<std::shared_mutex> w(m); // ❌ 死锁风险

必须：

1. 释放读锁

2. 再尝试写锁

---

6️⃣ 一个完整的小例子（推荐模板）

std::shared_mutex m;
int value = 0;

int read() {
    std::shared_lock<std::shared_mutex> r(m);
    return value;
}

void write(int v) {
    std::unique_lock<std::shared_mutex> w(m);
    value = v;
}

---

7️⃣ 一句话总结（记住这个）

shared_mutex 提供“读/写锁能力”，
shared_lock 负责“以 RAII 方式持有读锁”。

一句话结论先给你：

std::shared_lock 是对 lock_shared() / unlock_shared() 的 RAII 封装。

也就是说：

• lock_shared 是“动作（API）”

• shared_lock 是“帮你自动做这些动作的对象（RAII）”

下面把关系讲透。

---

1️⃣ lock_shared 是什么？

它是 std::shared_mutex（或 shared_timed_mutex）提供的成员函数：

std::shared_mutex m;

m.lock_shared();    // 获取“共享锁”（读锁）
...
m.unlock_shared();  // 释放“共享锁”

特点：

• 多个线程可同时成功

• 与写锁（lock()）互斥

• 不具备异常安全

• 必须手动成对调用

---

2️⃣ shared_lock 是什么？

它是一个 RAII 模板类，专门用于管理“共享锁”：

std::shared_lock<std::shared_mutex> r(m);

等价于（语义上）：

m.lock_shared();
try {
    // 读临界区
} finally {
    m.unlock_shared();
}

构造时：

• 调用 lock_shared()

析构时：

• 调用 unlock_shared()

---

3️⃣ 它们的“对应关系”（核心）

层级	名称	职责
底层原语	lock_shared()	真正执行“加读锁”
RAII 封装	std::shared_lock	自动管理 lock_shared / unlock_shared

👉 就像：

• mutex::lock() ↔ lock_guard

• mutex::lock() ↔ unique_lock

---

4️⃣ 为什么推荐 shared_lock 而不是直接 lock_shared()？

✅ 异常安全

m.lock_shared();
may_throw();  // ❌ 如果抛异常，unlock_shared 泄漏
m.unlock_shared();

vs

std::shared_lock r(m);
may_throw();  // ✅ 自动释放

---

✅ 作用域更清晰

{
    std::shared_lock r(m);
    // 受保护区域
}
// 一眼就知道：这里释放

---

✅ 更丰富的控制（高级用法）

std::shared_lock r(m, std::defer_lock);
r.lock();        // lock_shared
r.unlock();      // unlock_shared

std::shared_lock r(m, std::try_to_lock);
if (!r.owns_lock()) { /* 失败处理 */ }

---

5️⃣ 常见误区（一定要避开）

❌ 误区 1：shared_lock 可以管理普通 mutex

不行：

std::mutex m;
std::shared_lock<std::mutex> r(m); // ❌ 编译错误

shared_lock 只能用于 支持 lock_shared 的 mutex 类型。

---

❌ 误区 2：shared_lock 是“轻量版 unique_lock”

不对：

• shared_lock → 读锁

• unique_lock → 写锁

语义完全不同。

---

6️⃣ 一个最小可对照示例（记忆用）

std::shared_mutex m;

// 手动（不推荐）
m.lock_shared();
// read
m.unlock_shared();

// RAII（推荐）
{
    std::shared_lock<std::shared_mutex> r(m);
    // read
}

---

7️⃣ 一句话总结（记住这个）

lock_shared 是“怎么加读锁”，
shared_lock 是“帮你安全地持有读锁”。