C / C++ / 系统课时
遇到死锁怎样最短路径定位
遇到死锁怎样最短路径定位
死锁排查的关键不是先读大量代码,而是先确认哪些线程停在锁等待,再把线程栈还原成“谁持有哪把锁、又在等哪把锁”的闭环。下面用一个可复现的双锁死锁,串起 ps、gdb、锁关系分析和修复验证。
学习目标
- 用
ps快速确认进程仍存活、线程长期停在等待状态 - 用
gdb一次抓取全部线程栈,并从栈帧中定位互斥锁等待点 - 根据锁依赖闭环选择修复方式,并验证修复后线程可以正常结束
先确认是不是“活着但不前进”
先准备一个可重复触发死锁的程序。两个线程分别先拿到一把互斥锁,再等待对方持有的另一把锁;原子计数器只用于保证两个线程都已经拿到第一把锁。
#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,进程也不会自行退出。
编译并后台运行:
g++ -std=c++17 -O0 -g -pthread deadlock.cpp -o deadlock
./deadlock &
echo "PID=$!"预期输出:
PID=<ID>程序不会自行退出。记下实际 PID,然后查看线程状态:
ps -L -p <ID> -o pid,tid,stat,pcpu,wchan:32,comm预期输出(线程 ID、CPU 和 WCHAN 会因系统而异):
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 一次抓全线程栈
对目标进程执行批量回溯,避免手工逐个切线程:
gdb -q -p <ID> -batch \
-ex "set pagination off" \
-ex "info threads" \
-ex "thread apply all bt"预期输出会出现多个线程,其中两个工作线程的调用栈停在互斥锁获取路径,关键帧类似:
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 通常只能直接告诉你“线程卡在哪个锁调用点”,未必直接告诉你锁的业务名称。最短路径是把栈帧对应回源码中的加锁语句,再记录每个线程“已持有”和“正在等待”的锁;一旦发现环,就已经获得可操作的根因证据。
修复锁顺序并验证恢复
最直接的修复是让多个互斥量由同一个原子加锁操作统一获取,避免不同线程自行决定顺序。下面给出完整修复版:
#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 协调获取两把互斥锁,不再形成相反的嵌套加锁顺序。
编译并运行:
g++ -std=c++17 -O0 -g -pthread fixed.cpp -o fixed
./fixed预期输出:
worker_a entered critical section
worker_b entered critical section
all workers finished前两行顺序可能互换,但程序应正常退出。修复验收不只看“这次没挂”:应重复运行或压测,确认进程能持续前进、队列或请求完成数继续增长,并且再次抓取线程栈时,不再长期出现同一组线程互相等待相反锁顺序。