如何避免死锁?
一、什么是死锁
两个线程各自拿着对方需要的锁,互相等待,谁也不放手,程序就永远卡死。
#include <chrono>
#include <mutex>
#include <thread>
std::mutex mtxA, mtxB;
// 线程1:先拿 A,再要 B
void thread1() {
std::lock_guard<std::mutex> lockA(mtxA); // 拿到 A
std::this_thread::sleep_for(std::chrono::milliseconds(10)); // 放大交错窗口,让死锁必现
std::lock_guard<std::mutex> lockB(mtxB); // 等 B —— 但 B 在线程2手里
}
// 线程2:先拿 B,再要 A
void thread2() {
std::lock_guard<std::mutex> lockB(mtxB); // 拿到 B
std::this_thread::sleep_for(std::chrono::milliseconds(10));
std::lock_guard<std::mutex> lockA(mtxA); // 等 A —— 但 A 在线程1手里
// 💀 双方互相等待,永远卡死
}
卡死的时序(可类比 shared_ptr 的循环引用):
线程1: 锁A成功 ──→ 等B(B被线程2拿着)
线程2: 锁B成功 ──→ 等A(A被线程1拿着)
↑______________________↓ 循环等待,无人能让步
死锁不是单一原因造成的,而是四个条件同时满足才发生。只要破坏任意一个,死锁就不可能发生。
二、死锁的四大必要条件
| 条件 | 简介 | 破坏难度 |
|---|---|---|
| ① 互斥 | 资源同一时间只能被一个线程占有 | 几乎不可破坏 |
| ② 占有且等待 | 抱着一个资源,还要等另一个 | 可破坏 |
| ③ 不可剥夺 | 资源只能由持有者自己释放,不能被抢 | 可破坏 |
| ④ 环路等待 | 等待链成环:A 等 B,B 又等 A | 最容易破坏 |
2.1 互斥:基本不可破坏
加锁的目的就是互斥,如果允许并发写共享数据,就不需要锁了,但数据会坏。所以这个条件通常保留,思路变成”减少需要互斥的资源数量”:
// 用原子操作替代锁:天然无死锁
std::atomic<int> counter{0};
counter.fetch_add(1, std::memory_order_relaxed);
其他手段:数据改成 thread_local(各线程一份,不共享)、无锁数据结构。能不共享就不共享,能不锁就不锁。
2.2 占有且等待:一次性拿齐所有锁
破坏方法:不要”拿一个、再等下一个”,而是一次性申请所有需要的锁——要么全拿到,要么都不拿:
// ❌ 错误:分步加锁,"持有A等B"的窗口期就是死锁温床
void bad() {
std::lock_guard<std::mutex> lockA(mtxA); // 持有 A
std::lock_guard<std::mutex> lockB(mtxB); // 等 B 期间仍持有 A
}
// ✅ 正确(C++11):defer_lock 先不锁,std::lock 一次性锁两个
void good11() {
std::unique_lock<std::mutex> lockA(mtxA, std::defer_lock); // 先不锁
std::unique_lock<std::mutex> lockB(mtxB, std::defer_lock);
std::lock(lockA, lockB); // 一次性全部锁定
// 临界区
}
// ✅ 正确(C++17,更简洁,日常首选)
void good17() {
std::scoped_lock lock(mtxA, mtxB); // 一行搞定,析构时全部释放
// 临界区
}
std::lock() 内部用”尝试-回退-重试”的无死锁算法:中途拿不齐就把自己已拿到的放掉重来,所以不会形成占有且等待情况。std::scoped_lock 内部正是这个算法。
2.3 不可剥夺:拿不到就放手
破坏方法:用 try_lock() 非阻塞地尝试,失败就主动释放已持有的锁,稍后重试:
std::mutex mtx1, mtx2;
void thread_func() {
while (true) {
mtx1.lock();
if (mtx2.try_lock()) { // 尝试拿 mtx2,不阻塞
// 拿到了两把,干活
mtx2.unlock();
mtx1.unlock();
break;
} else {
mtx1.unlock(); // 主动放手,破坏"不可剥夺"
std::this_thread::yield(); // 让出 CPU,避免忙等
}
}
}
逻辑:先锁 mtx1 → try_lock 试 mtx2 → 成功就干活;失败就释放 mtx1、让出 CPU、重来。线程自愿放弃已占有的资源,“不可剥夺”被打破。
yield() 的作用:失败后让出 CPU。多提一句,如果采用对称式拿锁,可能产生活锁问题,yield() 只能缓解忙等,并不能真正消除活锁,彻底解法是指数退避 / 随机化重试间隔。
顺带认识超时版 try_lock_for():
std::timed_mutex mtx;
if (mtx.try_lock_for(std::chrono::milliseconds(100))) { // 最多等 100ms
// 拿到了
mtx.unlock();
} else {
// 超时,走降级/重试逻辑,而不是无限等下去
}
2.4 环路等待:全局锁排序(工程上最有效)
破坏方法:给所有锁规定一个全局顺序,所有线程严格按同样顺序加锁。
// ❌ 顺序相反 → 可能成环
线程1: mtxA → mtxB
线程2: mtxB → mtxA // 逆序!
// ✅ 全员同序 → 不可能成环
线程1: mtxA → mtxB
线程2: mtxA → mtxB
为什么同序就安全?要成环,必须有人”逆序”——大家都顺着同一个方向排队,环就闭不上。
经典场景:银行转账死锁:
// ❌ 危险:加锁顺序跟随参数方向
void transfer(Account& from, Account& to, int amount) {
std::lock_guard<std::mutex> lock1(from.mtx); // 先锁"转出方"
std::lock_guard<std::mutex> lock2(to.mtx); // 再锁"转入方"
from.balance -= amount;
to.balance += amount;
}
// 线程1: transfer(A, B) → 锁 A 再锁 B
// 线程2: transfer(B, A) → 锁 B 再锁 A ← 方向相反,经典死锁
修复思路一(锁排序思想):按账户 ID 排序后再加锁,保证任何线程都”先锁小 id、再锁大 id”:
// ✅ 按 id 排序,全局同序
void transfer(Account& from, Account& to, int amount) {
if(from.id == to.id) break;
Account& first = (from.id < to.id) ? from : to; // id 小的先锁
Account& second = (from.id < to.id) ? to : from;
std::lock_guard<std::mutex> lock1(first.mtx); // 任何线程恒为"小id → 大id"
std::lock_guard<std::mutex> lock2(second.mtx);
from.balance -= amount;
to.balance += amount;
}
修复思路二(更直接):std::scoped_lock 一次构造锁两把,内部无死锁算法保证方向相反也不会死锁:
// ✅ scoped_lock 一行解决(两把锁总在同一函数里的场景)
void transfer(Account& from, Account& to, int amount) {
std::scoped_lock lock(from.mtx, to.mtx);
from.balance -= amount;
to.balance += amount;
}
两个方案怎么选?scoped_lock 只能救”两把锁总是同时出现在一个函数里”的场景;一旦加锁分散在多层调用中(A 函数锁了第一把后才调 B 函数去锁第二把),scoped_lock 无从施展,只能靠排序规范兜底
三、工程实践拓展
3.1 缩小临界区、减少锁的数量
锁越多、持有越久,死锁概率越高。原则:
- 临界区只放必须互斥的代码,I/O、日志、计算统统移出去;
- 一个类一把锁够就别拆成多把;能不共享的数据(
thread_local、局部变量)就不共享。
3.2 持锁时不要调用”未知代码”
真实工程里最常见的隐死锁:持锁时调用了回调/虚函数/别的模块接口,而那个函数内部又去拿别的锁(或反过来调回本模块)。锁的调用图一复杂,“全局排序”就失控了。
std::lock_guard<std::mutex> lock(mtx);
callback(); // ❌ 危险:callback 内部拿什么锁你无法控制
实践:先在锁内把需要的数据拷出来,解锁后再调回调——“锁内只做数据操作,锁外做业务逻辑”。
3.3 RAII 锁守护:防止”人祸型”资源滞留
lock_guard / unique_lock / scoped_lock 都是 RAII:析构自动解锁,异常路径也不会忘记释放。注意它不能防止死锁四条件(该环还是会环),但能消灭”忘 unlock / 异常跳过 unlock 导致的互斥量永久占用”这类人为 bug——这是 RAII 与死锁关系的标准答法。
3.4 用工具检测:ThreadSanitizer
死锁难靠肉眼排查,编译期挂上 TSan 让它帮你盯着锁序:
g++ -fsanitize=thread -g main.cpp -o main && ./main
# 若检测到加锁顺序倒置,运行时会报告:
# WARNING: ThreadSanitizer: lock-order-inversion (potential deadlock)
面试被问”怎么排查死锁”时的答题链:复现卡住 → gdb thread apply all bt 看各线程卡在哪个锁上 → 找出互相等待的环 → 按锁排序修复;预防用 TSan。
3.5 死锁 vs 活锁 vs 饥饿
| 现象 | 表现 | 典型原因 |
|---|---|---|
| 死锁 | 线程永久阻塞,一动不动 | 环路等待 |
| 活锁 | 线程不停重试,但谁也前进不了,CPU 满转 | try_lock 重试不加退避 |
| 饥饿 | 个别线程一直抢不到资源 | 调度不公平 / 其他线程长期持锁 |
2.3 模板里 yield() 的作用:失败后让出 CPU,但 yield() 只能缓解忙等,并不能真正消除活锁,彻底解法是指数退避 / 随机化重试间隔。
四、总结:死锁预防方案优先级
| 优先级 | 策略 | 具体手段 |
|---|---|---|
| ★★★★★ | 破坏环路等待 | 全局锁排序 + 代码审查 + TSan 兜底 |
| ★★★★ | 破坏占有且等待 | std::scoped_lock / std::lock 一次性拿齐 |
| ★★★ | 破坏不可剥夺 | try_lock + 重试 / timed_mutex 超时 |
| ★ | 破坏互斥 | 原子操作 / thread_local / 无锁结构 |
总结:“互斥不可破坏;工程上首选锁排序 + scoped_lock 一次性加锁;无法排序的场景用 try_lock 超时兜底;TSan 做工具保障。”
五、速答卡
| 问题 | 30 秒答案 |
|---|---|
| 什么是死锁? | 多个线程互相等待对方持有的资源且都不释放,程序永久卡死。 |
| 死锁的四个必要条件? | 互斥、占有且等待、不可剥夺、环路等待。同时满足才发生,破坏任一即可避免。 |
| 哪个条件最该破坏? | 环路等待:全局锁排序,所有线程按同一顺序加锁。互斥基本不可破坏。 |
std::lock / scoped_lock 为什么不死锁? | 内部用”尝试-回退-重试”算法,拿不齐就全部放手重来,不形成占有且等待。 |
lock 和 try_lock 区别? | lock 阻塞直到拿到;try_lock 立即返回 false 不阻塞,配合重试破坏”不可剥夺”。 |
| 转账死锁怎么修?(手写题) | 按账户 id 排序后加锁保证全局同序,或用 std::scoped_lock 一次锁两把。 |
| RAII 锁能防止死锁吗? | 不能防四条件,但能防”忘记/异常跳过 unlock”造成的资源永久占用;多把锁还要靠顺序或 scoped_lock。 |
| 死锁和活锁区别? | 死锁是”卡住不动”;活锁是”不停重试但谁也前进不了”(CPU 在烧)。活锁靠加退避/随机化解决。 |
| 怎么排查死锁? | gdb 看所有线程栈找互相等待的环(thread apply all bt);TSan 检测锁序倒置;日志定位最后一条持锁记录。 |
| 减少死锁概率的编码习惯? | 缩小临界区、减少锁数量、持锁不调未知回调、固定加锁顺序、能 atomic 就不锁。 |
附:一页心智模型
死锁 = 四条件同时成立
├─ 互斥:不可破坏 → 只能减少共享(atomic / thread_local)
├─ 占有且等待 ──→ 一次性拿齐:std::scoped_lock / std::lock
├─ 不可剥夺 ────→ 拿不到就放手:try_lock + 重试 / timed_mutex
└─ 环路等待 ────→ 全局锁排序(工程第一防线 + TSan 兜底)
排查口诀:卡住 → 看线程栈 → 找等待环 → 排序修复
参考:cppreference - std::scoped_lock、《C++ Concurrency in Action》第 3 章、操作系统教材(死锁章)