工程实践

如何避免死锁?

一、什么是死锁

两个线程各自拿着对方需要的锁,互相等待,谁也不放手,程序就永远卡死。

#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 章、操作系统教材(死锁章)