锁

https://paul.pub/cpp-concurrency/

🔒 C++ 锁家族关系图

                ┌────────────────────────────────────────────┐
                │               互斥量 (Mutex)                │
                └────────────────────────────────────────────┘
                           │
        ┌──────────────┬───────────────┬────────────────┬─────────────────┐
        │              │               │                │                 │
   std::mutex   std::recursive_mutex   std::timed_mutex   std::recursive_timed_mutex
   (普通锁)     (可重入)               (带超时)          (可重入 + 带超时)


                           │
                ┌────────────────────────────────────────────┐
                │          共享互斥量 (Shared Mutex)           │
                └────────────────────────────────────────────┘
                           │
        ┌───────────────────────────────────────┬──────────────────────┐
        │                                       │                      │
 std::shared_mutex                      std::shared_timed_mutex
 (C++17, 支持读/写)                     (C++14, 支持读/写 + 超时)


                           │
                ┌────────────────────────────────────────────┐
                │          RAII 锁封装 (Lock Wrappers)        │
                └────────────────────────────────────────────┘
                           │
        ┌──────────────────┬──────────────────┬──────────────────┬─────────────────────┐
        │                  │                  │                  │
 std::lock_guard     std::unique_lock    std::scoped_lock     std::shared_lock
 (最简单 RAII)       (灵活控制锁)       (C++17, 多锁防死锁) (C++14, 专用于 shared_mutex)

C++ 标准库里的主要锁类型

C++ 从 C++11 开始引入多种互斥量（锁）和 RAII 封装：

🔹 基础互斥量（mutexes）

1. std::mutex

   • 最普通的互斥锁，不可递归。

2. std::recursive_mutex

   • 允许同一线程多次加锁（必须相同次数解锁）。

3. std::timed_mutex

   • 在 mutex 基础上增加了 try_lock_for 和 try_lock_until。

4. std::recursive_timed_mutex

   • 递归 + 超时功能。

---

🔹 读写锁（共享互斥量，C++14/17）

5. std::shared_mutex（C++17）

   • 允许多个线程读（shared lock），但写（unique lock）时排他。

6. std::shared_timed_mutex（C++14）

   • shared_mutex + 超时功能。

---

🔹 RAII 锁封装（lock wrappers）

这些不是互斥量，而是“上锁管理类”，构造时上锁，析构时解锁：

7. std::lock_guard

   • 最简单的 RAII 封装，只能管理一个锁。

   std::lock_guard<std::mutex> guard(m);

8. std::unique_lock

   • 更灵活，可以延迟上锁、提前解锁、转移所有权。

   std::unique_lock<std::mutex> ulock(m, std::defer_lock); ulock.lock();

9. std::scoped_lock（C++17）

   • 一次管理多个锁，避免死锁。

10. std::shared_lock（C++14/17）

• 专门用于 shared_mutex，表示“共享读锁”。

---

3. 小总结

• 互斥量类（mutex 家族）：控制访问。

• 封装类（lock_guard、unique_lock、scoped_lock、shared_lock）：简化管理，保证异常安全。

常用选择：

• 只需要简单上锁 → std::lock_guard。

• 需要灵活控制（延迟上锁、解锁） → std::unique_lock。

• 多锁避免死锁 → std::scoped_lock。

• 读多写少场景 → std::shared_mutex + std::shared_lock。