C / C++ / 系统课时

遇到死锁怎样最短路径定位

遇到死锁怎样最短路径定位

死锁排查的关键不是先读大量代码,而是先确认哪些线程停在锁等待,再把线程栈还原成“谁持有哪把锁、又在等哪把锁”的闭环。下面用一个可复现的双锁死锁,串起 ps、gdb、锁关系分析和修复验证。

学习目标

  • 用 ps 快速确认进程仍存活、线程长期停在等待状态
  • 用 gdb 一次抓取全部线程栈,并从栈帧中定位互斥锁等待点
  • 根据锁依赖闭环选择修复方式,并验证修复后线程可以正常结束

先确认是不是“活着但不前进”

先准备一个可重复触发死锁的程序。两个线程分别先拿到一把互斥锁,再等待对方持有的另一把锁;原子计数器只用于保证两个线程都已经拿到第一把锁。

cpp
#include <atomic>
#include <iostream>
#include <mutex>
#include <thread>

std::mutex mutex_a;
std::mutex mutex_b;
std::atomic<int> ready{0};

// 让两个线程都先持有第一把锁,再尝试获取第二把锁。
void worker_a() {
    std::lock_guard<std::mutex> first(mutex_a);
    ++ready;
    while (ready.load() < 2) {
        std::this_thread::yield();
    }
    std::lock_guard<std::mutex> second(mutex_b);
    std::cout << "worker_a done\n";
}

void worker_b() {
    std::lock_guard<std::mutex> first(mutex_b);
    ++ready;
    while (ready.load() < 2) {
        std::this_thread::yield();
    }
    std::lock_guard<std::mutex> second(mutex_a);
    std::cout << "worker_b done\n";
}

int main() {
    // join 会永久等待,便于用 ps 和 gdb 观察死锁现场。
    std::thread a(worker_a);
    std::thread b(worker_b);
    a.join();
    b.join();
}

预期结果:保存为 deadlock.cpp 后可用 C++17 编译;运行时两个工作线程会形成循环等待,因此不会打印 done,进程也不会自行退出。

编译并后台运行:

bash
g++ -std=c++17 -O0 -g -pthread deadlock.cpp -o deadlock
./deadlock &
echo "PID=$!"

预期输出:

text
PID=<ID>

程序不会自行退出。记下实际 PID,然后查看线程状态:

bash
ps -L -p <ID> -o pid,tid,stat,pcpu,wchan:32,comm

预期输出(线程 ID、CPU 和 WCHAN 会因系统而异):

text
    PID     TID STAT %CPU WCHAN                            COMMAND
   <ID>    <ID> Sl    <N> futex_wait_queue                deadlock
   <ID>    <ID> Sl    <N> futex_wait_queue                deadlock
   <ID>    <ID> Sl    <N> futex_wait_queue                deadlock

如果进程仍存在、CPU 长时间很低、多个业务线程持续停在 futex 或锁等待相关位置,就值得立即进入线程栈检查;仅凭一次 ps 不能证明死锁,但能快速排除“进程已经退出”或“线程仍在持续计算”。

用 gdb 一次抓全线程栈

对目标进程执行批量回溯,避免手工逐个切线程:

bash
gdb -q -p <ID> -batch \
  -ex "set pagination off" \
  -ex "info threads" \
  -ex "thread apply all bt"

预期输出会出现多个线程,其中两个工作线程的调用栈停在互斥锁获取路径,关键帧类似:

text
Thread <ID> (...)
#0  ... futex_wait ...
#1  ... pthread_mutex_lock ...
#2  ... std::mutex::lock()
#3  ... worker_a()

Thread <ID> (...)
#0  ... futex_wait ...
#1  ... pthread_mutex_lock ...
#2  ... std::mutex::lock()
#3  ... worker_b()

实际 libc、libstdc++ 版本会让中间函数名和地址不同,因此定位时优先看最靠近业务代码的栈帧:这里分别是 worker_a() 和 worker_b(),说明两个线程都卡在第二次加锁。

把线程栈还原成锁依赖闭环

当前程序的关系是:线程 A 已持有 mutex_a,等待 mutex_b;线程 B 已持有 mutex_b,等待 mutex_a。只要这四条关系闭合成环,等待就不会自行消失。

双线程双锁死锁依赖闭环

在真实项目里,gdb 通常只能直接告诉你“线程卡在哪个锁调用点”,未必直接告诉你锁的业务名称。最短路径是把栈帧对应回源码中的加锁语句,再记录每个线程“已持有”和“正在等待”的锁;一旦发现环,就已经获得可操作的根因证据。

修复锁顺序并验证恢复

最直接的修复是让多个互斥量由同一个原子加锁操作统一获取,避免不同线程自行决定顺序。下面给出完整修复版:

cpp
#include <iostream>
#include <mutex>
#include <thread>

std::mutex mutex_a;
std::mutex mutex_b;

void worker(const char* name) {
    // 一次性协调获取两把锁,避免不同线程形成相反的嵌套顺序。
    std::scoped_lock lock(mutex_a, mutex_b);
    std::cout << name << " entered critical section\n";
}

int main() {
    // 两个线程竞争同一组锁,但不会形成循环等待。
    std::thread a(worker, "worker_a");
    std::thread b(worker, "worker_b");
    a.join();
    b.join();
    std::cout << "all workers finished\n";
}

预期结果:保存为 fixed.cpp 后,两条工作线程会通过 std::scoped_lock 协调获取两把互斥锁,不再形成相反的嵌套加锁顺序。

编译并运行:

bash
g++ -std=c++17 -O0 -g -pthread fixed.cpp -o fixed
./fixed

预期输出:

text
worker_a entered critical section
worker_b entered critical section
all workers finished

前两行顺序可能互换,但程序应正常退出。修复验收不只看“这次没挂”:应重复运行或压测,确认进程能持续前进、队列或请求完成数继续增长,并且再次抓取线程栈时,不再长期出现同一组线程互相等待相反锁顺序。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

遇到死锁怎样最短路径定位

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通