多线程中如何使用gdb精确定位死锁问题

lsekfe

在多线程开发过程中很多人应该都会遇到死锁问题，死锁问题也是面试过程中经常被问到的问题，这里介绍在c++中如何使用gdb+python脚本调试死锁问题，以及如何在程序运行过程中检测死锁。
　　首先介绍什么是死锁，看下维基百科中的定义：
　　死锁(英语：Deadlock)，又译为死结，计算机科学名词。当两个以上的运算单元，双方都在等待对方停止运行，以获取系统资源，但是没有一方提前退出时，就称为死锁。在多任务操作系统中，操作系统为了协调不同行程，能否获取系统资源时，为了让系统运作，必须要解决这个问题。
　　维基百科中介绍的是进程死锁，多线程中也会产生死锁，一样的道理，这里不作过多介绍。
　　死锁的四个条件
　　·禁止抢占(no preemption)：系统资源不能被强制从一个进程(线程)中退出，已经获得的资源在未使用完之前不能被抢占。
　　·等待和保持(hold and wait)：一个进程(线程)因请求资源阻塞时，对已获得的资源保持不放。
　　·互斥(mutual exclusion)：资源只能同时分配给一个进程(线程)，无法多个进程(线程)共享。
　　·循环等待(circular waiting)：一系列进程(线程)互相持有其他进程(线程)所需要的资源。
　　只有同时满足以上四个条件，才会产生死锁，想要消除死锁只需要破坏其中任意一个条件即可。
　　如何调试多线程死锁问题
　　多线程出现死锁的大部分原因都是因为多个线程中加锁的顺序不一致导致的，看如下这段会出现死锁的代码：

1. using std::cout;
   
2. 
   
3. 　　
   
4. 
   
5. 　　std::mutex mutex1;
   
6. 
   
7. 　　std::mutex mutex2;
   
8. 
   
9. 　　std::mutex mutex3;
   
10. 
    
11. 　　
    
12. 
    
13. 　　void FuncA() {
    
14. 
    
15. 　　   std::lock_guard<std::mutex> guard1(mutex1);
    
16. 
    
17. 　　   std::this_thread::sleep_for(std::chrono::seconds(1));
    
18. 
    
19. 　　   std::lock_guard<std::mutex> guard2(mutex2);
    
20. 
    
21. 　　   std::this_thread::sleep_for(std::chrono::seconds(1));
    
22. 
    
23. 　　}
    
24. 
    
25. 　　
    
26. 
    
27. 　　void FuncB() {
    
28. 
    
29. 　　   std::lock_guard<std::mutex> guard2(mutex2);
    
30. 
    
31. 　　   std::this_thread::sleep_for(std::chrono::seconds(1));
    
32. 
    
33. 　　   std::lock_guard<std::mutex> guard3(mutex3);
    
34. 
    
35. 　　   std::this_thread::sleep_for(std::chrono::seconds(1));
    
36. 
    
37. 　　}
    
38. 
    
39. 　　
    
40. 
    
41. 　　void FuncC() {
    
42. 
    
43. 　　   std::lock_guard<std::mutex> guard3(mutex3);
    
44. 
    
45. 　　   std::this_thread::sleep_for(std::chrono::seconds(1));
    
46. 
    
47. 　　   std::lock_guard<std::mutex> guard1(mutex1);
    
48. 
    
49. 　　   std::this_thread::sleep_for(std::chrono::seconds(1));
    
50. 
    
51. 　　}
    
52. 
    
53. 　　
    
54. 
    
55. 　　int main() {
    
56. 
    
57. 　　   std::thread A(FuncA);
    
58. 
    
59. 　　   std::thread B(FuncB);
    
60. 
    
61. 　　   std::thread C(FuncC);
    
62. 
    
63. 　　
    
64. 
    
65. 　　   std::this_thread::sleep_for(std::chrono::seconds(5));
    
66. 
    
67. 　　
    
68. 
    
69. 　　   if (A.joinable()) {
    
70. 
    
71. 　　       A.join();
    
72. 
    
73. 　　  }
    
74. 
    
75. 　　   if (B.joinable()) {
    
76. 
    
77. 　　       B.join();
    
78. 
    
79. 　　  }
    
80. 
    
81. 　　   if (C.joinable()) {
    
82. 
    
83. 　　       C.join();
    
84. 
    
85. 　　  }
    
86. 
    
87. 　　   cout << "hello\n";
    
88. 
    
89. 　　   return 0;
    
90. 
    
91. 　　}

复制代码

　如图：



·线程A已经持有mutex1，想要申请mutex2，拿到mutex2后才可以释放mutex1和mutex2，而此时mutex2被线程B占用。
　　·线程B已经持有mutex2，想要申请mutex3，拿到mutex3后才可以释放mutex2和mutex3，而此时mutex3被线程C占用。
　　·线程C已经持有mutex3，想要申请mutex1，拿到mutex1后才可以释放mutex3和mutex1，而此时mutex1被线程A占用。
　　三个线程谁也不让着谁，导致了死锁。
　　传统gdb调试多线程死锁方法
　　(1)attach id关联到发生死锁的进程id：

1. 　(gdb) attach 109
   
2. 
   
3. 　　Attaching to process 109
   
4. 
   
5. 　　[New LWP 110]
   
6. 
   
7. 　　[New LWP 111]
   
8. 
   
9. 　　[New LWP 112]
   
10. 
    
11. 　　[Thread debugging using libthread_db enabled]
    
12. 
    
13. 　　Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
    
14. 
    
15. 　　0x00007fa33f9e8d2d in __GI___pthread_timedjoin_ex (threadid=140339109693184, thread_return=0x0, abstime=0x0,
    
16. 
    
17. 　　block=<optimized out>) at pthread_join_common.c:89
    
18. 
    
19. 　　89      pthread_join_common.c: No such file or directory.

复制代码

　(2)info threads查看当前进程中所有线程的信息，也可以查看到部分堆栈信息。

1. 　(gdb) info threads
   
2. 
   
3. 　　Id   Target Id         Frame
   
4. 
   
5. 　　* 1    Thread 0x7fa33ff10740 (LWP 109) "out" 0x00007fa33f9e8d2d in __GI___pthread_timedjoin_ex (
   
6. 
   
7. 　　threadid=140339109693184, thread_return=0x0, abstime=0x0, block=<optimized out>) at pthread_join_common.c:89
   
8. 
   
9. 　　2    Thread 0x7fa33ec80700 (LWP 110) "out" __lll_lock_wait () at ../sysdeps/unix/sysv/linux/x86_64/lowlevellock.S:135
   
10. 
    
11. 　　3    Thread 0x7fa33e470700 (LWP 111) "out" __lll_lock_wait () at ../sysdeps/unix/sysv/linux/x86_64/lowlevellock.S:135
    
12. 
    
13. 　　4    Thread 0x7fa33dc60700 (LWP 112) "out" __lll_lock_wait () at ../sysdeps/unix/sysv/linux/x86_64/lowlevellock.S:135

复制代码

这里可以看到2、3、4线程都在lock_wait状态，基本上可以看出或许是否问题，但是不一定，这里需要多次info threads看看这些线程有没有什么变化，多次如果都没有变化那基本上就是发生了死锁。　　(3)thread id进入具体线程：

1. (gdb) thread 2
   
2. 
   
3. 　　[Switching to thread 2 (Thread 0x7fa33ec80700 (LWP 110))]
   
4. 
   
5. 　　#0 __lll_lock_wait () at ../sysdeps/unix/sysv/linux/x86_64/lowlevellock.S:135
   
6. 
   
7. 　　135     ../sysdeps/unix/sysv/linux/x86_64/lowlevellock.S: No such file or directory.

复制代码

(4)bt查看当前线程堆栈信息：

1. (gdb) bt
   
2. 
   
3. 　　#0 __lll_lock_wait () at ../sysdeps/unix/sysv/linux/x86_64/lowlevellock.S:135
   
4. 
   
5. 　　#1 0x00007fa33f9ea023 in __GI___pthread_mutex_lock (mutex=0x7fa340204180 <mutex2>) at ../nptl/pthread_mutex_lock.c:78
   
6. 
   
7. 　　#2 0x00007fa340000fff in __gthread_mutex_lock(pthread_mutex_t*) ()
   
8. 
   
9. 　　#3 0x00007fa3400015b2 in std::mutex::lock() ()
   
10. 
    
11. 　　#4 0x00007fa3400016d8 in std::lock_guard<std::mutex>::lock_guard(std::mutex&) ()
    
12. 
    
13. 　　#5 0x00007fa34000109b in FuncA() ()
    
14. 
    
15. 　　#6 0x00007fa340001c07 in void std::__invoke_impl<void, void (*)()>(std::__invoke_other, void (*&&)()) ()

复制代码

　调试到这里基本已经差不多了，针对pthread_mutex_t却可以打印出被哪个线程持有，之后再重复步骤3和4，就可以确定哪几个线程以及哪几把锁发生的死锁，而针对于std::mutex，gdb没法打印具体的mutex的信息，不能看出来mutex是被哪个线程持有，只能依次进入线程查看堆栈信息。　　然而针对于c++11的std::mutex有没有什么好办法定位死锁呢?
　　有。
　　可以算作第五步，继续：
　　(5)source加载deadlock.py脚本：

1. (gdb) source -v deadlock.py
   
2. 
   
3. 　　Type "deadlock" to detect deadlocks.

复制代码

　(6)输入deadlock检测死锁

1. (gdb) deadlock
   
2. 
   
3. 　　[Switching to thread 3 (Thread 0x7f5585670700 (LWP 123))]
   
4. 
   
5. 　　#0 __lll_lock_wait () at ../sysdeps/unix/sysv/linux/x86_64/lowlevellock.S:135
   
6. 
   
7. 　　135     in ../sysdeps/unix/sysv/linux/x86_64/lowlevellock.S
   
8. 
   
9. 　　[Switching to thread 4 (Thread 0x7f5584e60700 (LWP 124))]
   
10. 
    
11. 　　#0 __lll_lock_wait () at ../sysdeps/unix/sysv/linux/x86_64/lowlevellock.S:135
    
12. 
    
13. 　　135     in ../sysdeps/unix/sysv/linux/x86_64/lowlevellock.S
    
14. 
    
15. 　　[Switching to thread 2 (Thread 0x7f5585e80700 (LWP 122))]
    
16. 
    
17. 　　#0 __lll_lock_wait () at ../sysdeps/unix/sysv/linux/x86_64/lowlevellock.S:135
    
18. 
    
19. 　　135     in ../sysdeps/unix/sysv/linux/x86_64/lowlevellock.S
    
20. 
    
21. 　　#1 0x00007f5586bea023 in __GI___pthread_mutex_lock (mutex=0x7f5587404180 <mutex2>) at ../nptl/pthread_mutex_lock.c:78
    
22. 
    
23. 　　[Switching to thread 3 (Thread 0x7f5585670700 (LWP 123))]
    
24. 
    
25. 　　#0 __lll_lock_wait () at ../sysdeps/unix/sysv/linux/x86_64/lowlevellock.S:135
    
26. 
    
27. 　　#1 0x00007f5586bea023 in __GI___pthread_mutex_lock (mutex=0x7f55874041c0 <mutex3>) at ../nptl/pthread_mutex_lock.c:78
    
28. 
    
29. 　　[Switching to thread 4 (Thread 0x7f5584e60700 (LWP 124))]
    
30. 
    
31. 　　#0 __lll_lock_wait () at ../sysdeps/unix/sysv/linux/x86_64/lowlevellock.S:135
    
32. 
    
33. 　　#1 0x00007f5586bea023 in __GI___pthread_mutex_lock (mutex=0x7f5587404140 <mutex1>) at ../nptl/pthread_mutex_lock.c:78
    
34. 
    
35. 　　Found deadlock!
    
36. 
    
37. 　　Thread 2 (LWP 122) is waiting on pthread_mutex_t (0x00007f5587404180) held by Thread 3 (LWP 123)
    
38. 
    
39. 　　Thread 3 (LWP 123) is waiting on pthread_mutex_t (0x00007f55874041c0) held by Thread 4 (LWP 124)
    
40. 
    
41. 　　Thread 4 (LWP 124) is waiting on pthread_mutex_t (0x00007f5587404140) held by Thread 2 (LWP 122)

复制代码

直接看结果，脚本检测出了死锁，并指明了具体的哪几个线程造成的死锁，根据输出信息可以明显看出来线程锁形成的环造成了死锁，找到了具体是哪几个线程构成的死锁环，就可以查看相应线程的堆栈信息查看到哪几把锁正在等待。
死锁检测脚本的原理：

还是拿上面图举例：　　·线程A已经持有mutex1，想要申请mutex2，拿到mutex2后才可以释放mutex1和mutex2，而此时mutex2被线程B占用。
　　·线程B已经持有mutex2，想要申请mutex3，拿到mutex3后才可以释放mutex2和mutex3，而此时mutex3被线程C占用。
　　·线程C已经持有mutex3，想要申请mutex1，拿到mutex1后才可以释放mutex3和mutex1，而此时mutex1被线程A占用。


如图，三个线程形成了一个环，死锁检测就是检查线程之间是否有环的存在。单独检查死锁的环比较容易，这里延申下还涉及到简单环的概念，因为正常检测出来的环可能是个大环，不是权值顶点数最少的环，如果检测的环的顶点数较多，加大定位的代价，脚本就是检测的简单环，这里涉及到强连通分量算法和简单环算法，比较繁琐就不过多介绍了，脚本来源于facebook的folly库(这里推荐看下google的abseil和facebook的folly，都是好东西)，代码较长在文中不好列出，如果有需要的话可以自行下载或者关注加我好友发给你。　　如何在代码中检测死锁
　　和上面介绍的原理相同，在线程加锁过程中始终维护一张图，记录线程之间的关系
　　A->B, B->C, C->A