目录
1. 什么是死锁？一个生活中的比喻
2. 死锁的四个必要条件（科夫曼条件）
a. 互斥 (Mutual Exclusion)
b. 持有并等待 (Hold and Wait)
c. 不可抢占 (No Preemption)
d. 循环等待 (Circular Wait)
3. 如何处理死锁？
死锁预防：破坏四个必要条件之一
4. C++ 标准库提供的“死锁安全带”
std::lock 和 std::scoped_lock (C++17)
1. 什么是死锁？一个生活中的比喻想象一个场景：在一个狭窄的单行道上，两辆车迎面相遇。
车A 想要前进，但被 车B 挡住了。
车B 也想前进，但被 车A 挡住了。
两辆车都占着自己当前的路（持有资源），同时又在等待对方让出道路（请求资源）。如果两位司机都互不相让，他们就会永远卡在这里，谁也动不了。这种情况，就是死锁。
在并发编程中，“车”就是线程，“道路”就是资源（最常见的是互斥锁 std::mutex）。
死锁的正式定义：指两个或多个并发线程，在执行过程中因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。
2. 死锁的四个必要条件（科夫曼条件）一个死锁的发生，必须同时满足以下全部四个条件。只要破坏其中任意一个，死锁就不会发生。
a. 互斥 (Mutual Exclusion)定义：一个资源在同一时刻只能被一个线程持有。如果其他线程想使用该资源，必须等待直到资源被释放。
比喻：打印机在任何时候只能打印一个人的文件。在你打印完成之前，其他人必须等待。
编程体现：std::mutex 本身就是互斥的。lock() 操作确保了只有一个线程能进入临界区。这个条件在并发编程中通常是无法避免的，因为我们就是需要用锁来保护共享资源。
b. 持有并等待 (Hold and Wait)定义：一个线程至少持有一个资源，并且正在请求另一个被其他线程持有的资源。在等待新资源的同时，它并不会释放自己已经持有的资源。
比喻：你手里拿着一支笔（持有资源1），现在你需要一张纸来写字，但纸在另一个人手里。你在等待他给你纸的同时，并没有放下你手中的笔。
编程体现：
std::lock_guard lock1(mtx1); // 持有 mtx1
// ...做一些事...
std::lock_guard lock2(mtx2); // 等待 mtx2 c. 不可抢占 (No Preemption)定义：资源不能被强制地从持有它的线程中“抢”走。只能由持有者在完成任务后自愿释放。
比喻：别人不能从你手里强行夺走你正在使用的笔。你必须自己决定什么时候用完并把它放下。
编程体现：当一个线程通过 lock() 获得了互斥锁，操作系统或其他线程无法强制它 unlock()。它必须自己执行到作用域结束（对于 lock_guard）或手动调用 unlock()。
d. 循环等待 (Circular Wait)定义：存在一个线程的等待链，形成一个闭环。
线程 T1 正在等待线程 T2 持有的资源。
线程 T2 正在等待线程 T3 持有的资源。
...
线程 Tn 最终等待线程 T1 持有的资源。
比喻：
你想借小明的钢笔，但小明说必须先借到小红的笔记本才行。
而小红说，她必须先借到你的橡皮擦，才肯借出笔记本。
于是，你等小明，小明等小红，小红又在等你。三个人陷入了无限的循环等待。
最经典的编程场景：
// 线程 1
void func1() {
std::lock_guard lock1(mtx1); // 1. 锁住 mtx1
std::this_thread::sleep_for(std::chrono::milliseconds(10));
std::lock_guard lock2(mtx2); // 2. 尝试锁住 mtx2 (等待线程2释放)
}
// 线程 2
void func2() {
std::lock_guard lock2(mtx2); // 1. 锁住 mtx2
std::this_thread::sleep_for(std::chrono::milliseconds(10));
std::lock_guard lock1(mtx1); // 2. 尝试锁住 mtx1 (等待线程1释放)
} 如果 func1 和 func2 并发执行，func1 可能锁住 mtx1 等待 mtx2，而 func2 同时锁住了 mtx2 等待 mtx1，这就形成了循环等待，导致死锁。
3. 如何处理死锁？主要有三种策略：预防、避免、检测与恢复。在应用级编程中，我们最关心的是死锁预防。
死锁预防：破坏四个必要条件之一预防死锁的核心思想，就是通过编码规范和设计，来破坏四个必要条件中的至少一个。
破坏“互斥”：
方法：允许多个线程同时访问资源。
可行性：很低。对于打印机、共享计数器这类资源，我们就是为了互斥才加锁的。但对于只读数据，可以使用无锁数据结构或原子操作 std::atomic 来代替互斥锁。
破坏“持有并等待”：
方法：规定线程在请求资源前，不能持有任何其他资源。要么一次性申请所有需要的资源，要么在申请新资源前，先释放已持有的所有资源。
可行性：较低。很难预知一个任务到底需要哪些资源，且“先释放再申请”可能导致线程活锁（不断尝试但总失败）。
破坏“不可抢占”：
方法：允许系统或优先级更高的线程抢占资源。
可行性：极低。在应用层面几乎无法实现，且会使程序逻辑变得异常复杂。
破坏“循环等待” (最实用、最常用的策略)
方法：对所有资源（互斥锁）进行全局排序，并强制所有线程都必须按照这个统一的顺序来获取锁。
可行性：非常高，是预防死锁的黄金法则。
比喻：规定所有司机在十字路口都必须先让右边的车。这样就不会出现所有车都想抢先而堵死的局面。
编程实现：
std::mutex mtx1, mtx2;
// 假设我们规定，必须先锁地址较小的互斥量
// 这是一个全局统一的顺序
// 线程 1
void func1_fixed() {
// 总是按 mtx1 -> mtx2 的顺序加锁
std::lock_guard lock1(mtx1);
std::lock_guard lock2(mtx2);
}
// 线程 2
void func2_fixed() {
// 同样遵守 mtx1 -> mtx2 的顺序
std::lock_guard lock1(mtx1);
std::lock_guard lock2(mtx2);
} 通过强制所有线程都遵循 mtx1 -> mtx2 的加锁顺序，就打破了循环等待的可能性，从根本上消除了死锁。
4. C++ 标准库提供的“死锁安全带”手动管理锁的顺序很麻烦且容易出错。为此，C++ 标准库提供了更高级的工具来自动处理这个问题。
std::lock 和 std::scoped_lock (C++17)当你需要同时锁定多个互斥锁时，应该使用它们。
std::lock(mtx1, mtx2, ...): 这是一个函数，可以一次性、无死锁地锁定传入的所有互斥锁。它内部实现了一套避免死锁的算法（例如，它会尝试锁定，如果某个锁失败了，它会解开所有已锁定的锁，然后重试）。
std::scoped_lock(mtx1, mtx2, ...) (C++17, 最佳选择): 这是一个 RAII 风格的类，是 std::lock 的现代化封装。它在构造时自动调用 std::lock 来安全地锁定所有互斥锁，在析构时（离开作用域时）自动将它们全部解锁。
#include
#include
std::mutex mtx_A, mtx_B;
void safe_operation() {
// 只需要一行代码，就能安全、无死锁地锁定两个互斥锁
// 无需关心 mtx_A 和 mtx_B 的顺序
std::scoped_lock lock(mtx_A, mtx_B);
// ... 在此作用域内，mtx_A 和 mtx_B 都被安全锁定 ...
// ... 执行你的操作 ...
} // lock 析构时，会自动解锁 mtx_A 和 mtx_B
结论：在需要同时锁定多个互斥锁的场景下，永远优先使用 std::scoped_lock。这是现代 C++ 中预防死锁的最佳实践。