Linux GDB分析死锁

最新推荐文章于 2025-02-22 15:15:19 发布
最新推荐文章于 2025-02-22 15:15:19 发布
阅读量417 收藏
点赞数
分类专栏： c++11 linux 文章标签： linux c++
原文链接：https://blog.youkuaiyun.com/u014023993/article/details/102991571
版权

目录

示例代码

分析

结论

示例代码


   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       // DeadLock.cpp : 定义控制台应用程序的入口点。
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       //
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #include <iostream>
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #include <stdlib.h>
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #include <thread>
      
      
    
     
     
  7. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #include <mutex>
      
      
    
     
     
  8. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  9. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       static std::mutex mutex1;
      
      
    
     
     
  10. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       static std::mutex mutex2;
      
      
    
     
     
  11. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  12. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       static int threadFunc1()
      
      
    
     
     
  13. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       {		
      
      
    
     
     
  14. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       	std::cout << 
       
       "Enter threadFunc1" << std::endl;
      
      
    
     
     
  15. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    	
       
       std::lock_guard<std::mutex> lock1(mutex1);	
      
      
    
     
     
  16. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       	std::this_thread::
       
       sleep_for(std::chrono::
       
       seconds(
       
       20));
      
      
    
     
     
  17. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    	
       
       std::lock_guard<std::mutex> lock2(mutex2);
      
      
    
     
     
  18. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       	std::cout << 
       
       "Leave threadFunc1" << std::endl;	
      
      
    
     
     
  19. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    	
       
       return 
       
       0;
      
      
    
     
     
  20. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       }
      
      
    
     
     
  21. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  22. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       static int threadFunc2()
      
      
    
     
     
  23. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       {
      
      
    
     
     
  24. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       	std::cout << 
       
       "Enter threadFunc2" << std::endl;
      
      
    
     
     
  25. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    	
       
       std::lock_guard<std::mutex> lock1(mutex2);		
      
      
    
     
     
  26. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       	std::this_thread::
       
       sleep_for(std::chrono::
       
       seconds(
       
       20));	
      
      
    
     
     
  27. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    	
       
       std::lock_guard<std::mutex> lock2(mutex1);
      
      
    
     
     
  28. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       	std::cout << 
       
       "Leave threadFunc2" << std::endl;	
      
      
    
     
     
  29. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    	
       
       return 
       
       0;
      
      
    
     
     
  30. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       }
      
      
    
     
     
  31. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  32. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       int main()
      
      
    
     
     
  33. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       {
      
      
    
     
     
  34. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    	
       
       std::thread thread1(threadFunc1);
      
      
    
     
     
  35. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    	
       
       std::thread thread2(threadFunc2);
      
      
    
     
     
  36. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    	
      
      
    
     
     
  37. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       	thread1.
       
       join();
      
      
    
     
     
  38. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       	thread2.
       
       join();
      
      
    
     
     
  39. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  40. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       	std::cout << 
       
       "All thread end,now exit" << std::endl;	
      
      
    
     
     
  41. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       return 
       
       0;
      
      
    
     
     
  42. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       }

编译运行（目标程序为testDemo）：./testDemo

Enter threadFunc1

Enter threadFunc2

并未输出：Leave threadFunc1 、 Leave threadFunc2、All thread end,now exit，随后程序处于挂起状态

分析

1、Gdb调试：gdb ./testDemo

2、 待到程序无反应时，通过Ctrl+C中断程序运行

3、查看线程信息：info threads

Id   Target Id         Frame

* 1    Thread 0x7ffff7fdb740 (LWP 4315) "testDemo" 0x00007ffff7bbed2d in __GI___pthread_timedjoin_ex (threadid=140737335809792, thread_return=0x0,

    abstime=0x0, block=<optimized out>) at pthread_join_common.c:89

  2    Thread 0x7ffff6e85700 (LWP 4319) "testDemo" __lll_lock_wait () at ../sysdeps/unix/sysv/linux/x86_64/lowlevellock.S:135

  3    Thread 0x7ffff6684700 (LWP 4320) "testDemo" __lll_lock_wait () at ../sysdeps/unix/sysv/linux/x86_64/lowlevellock.S:135

我们看到，一共有三个线程，分别为主线程，以及两个子线程，线程号分别为4319及4320。并且两个子线程都处于锁等待的状态。

4、查看子线程4319堆栈信息：thread 2; bt（2 是相对线程号）

#0  __lll_lock_wait () at ../sysdeps/unix/sysv/linux/x86_64/lowlevellock.S:135

#1  0x00007ffff7bc0023 in __GI___pthread_mutex_lock (mutex=0x5555557581a0 <mutex2>) at ../nptl/pthread_mutex_lock.c:78

#2  0x00005555555550bf in __gthread_mutex_lock (__mutex=0x5555557581a0 <mutex2>) at /usr/include/x86_64-linux-gnu/c++/7/bits/gthr-default.h:748

#3  0x0000555555555614 in std::mutex::lock (this=0x5555557581a0 <mutex2>) at /usr/include/c++/7/bits/std_mutex.h:103

#4  0x0000555555555690 in std::lock_guard<std::mutex>::lock_guard (this=0x7ffff6e84dc0, __m=...) at /usr/include/c++/7/bits/std_mutex.h:162

#5  0x0000555555555183 in threadFunc1 () at DeadLock.cpp:17

省略…..

子线程4319在等待mutex2

5、查看子线程4320堆栈信息：thread 3; bt（3 是相对线程号）

#0  __lll_lock_wait () at ../sysdeps/unix/sysv/linux/x86_64/lowlevellock.S:135

#1  0x00007ffff7bc0023 in __GI___pthread_mutex_lock (mutex=0x555555758160 <mutex1>) at ../nptl/pthread_mutex_lock.c:78

#2  0x00005555555550bf in __gthread_mutex_lock (__mutex=0x555555758160 <mutex1>) at /usr/include/x86_64-linux-gnu/c++/7/bits/gthr-default.h:748

#3  0x0000555555555614 in std::mutex::lock (this=0x555555758160 <mutex1>) at /usr/include/c++/7/bits/std_mutex.h:103

#4  0x0000555555555690 in std::lock_guard<std::mutex>::lock_guard (this=0x7ffff6683dc0, __m=...) at /usr/include/c++/7/bits/std_mutex.h:162

#5  0x000055555555529e in threadFunc2 () at DeadLock.cpp:27

子线程4320在等待锁mutex1

6、查看mutex1、mutex2的信息

p mutex1：

{

  <std::__mutex_base> = {

    _M_mutex = pthread_mutex_t = {

      Type = Normal,

      Status = Acquired, possibly with waiters,

      Owner ID = 4319,

      Robust = No,

      Shared = No,

      Protocol = None

    }

  }

p mutex2：

{

  <std::__mutex_base> = {

    _M_mutex = pthread_mutex_t = {

      Type = Normal,

      Status = Acquired, possibly with waiters,

      Owner ID = 4320,

      Robust = No,

      Shared = No,

      Protocol = None

    }

  }

mutex1的当前所属线程是4319（相对线程号为2），mutex2的当前所属线程是4320（相对线程号为3）。同时，mutex1及mutex2中的Status字段均表示其已经被获取，并且可能有等待者。

结论

将上述分析结果以表格形式汇总：

相对线程号

线程号

拥有锁

等待锁

2

4319

mutex1

mutex2

3

4320

mutex2

mutex1

从汇总结果看，线程4319,43202形成了死锁，导致程序挂起。

扫描二维码，关注“清远的梦呓”公众号，发现更多文章

 

Linux GDB调试死锁问题， my test
小硕算法工程师
01-17 776
由于多线程的模式下，各个线程并发运行（注意“并发和“并行”的区别），为了保证各个线程对公共资源的访问时出现数据不一致性的问题，出现了锁的机制。Linux系统编程中最常见的锁机制是通过互斥量（mutex）来实现的。任一时刻只有一个线程可以对互斥量mutex上锁（或说成持有该互斥量），在被持有期间，其它线程就无法对它进行上锁（这也是互斥量名字中“互斥”的由来），其它尝试加锁的线程都会休眠（注意休眠和挂起的区别）释放cpu资源，并被记录到此互斥量的等待队列中。
GDB 查看死锁
09-17 1443
死锁：一种情形，此时执行程序中两个或多个线程发生永久堵塞（等待），每个线程都在等待被   其他线程占用并堵塞了的资源。例如，如果线程A锁住了记录1并等待记录2，而线程B锁住了记录2并等待记录1，这样两个线程就发生了死锁现象。 gdb调试死锁的方法： gdb  attach pid thread apply all bt 找到_lll_lo
Linux C++编程死锁排查：借助Shell与GDB找到真相
最新发布
深度Linux
02-22 648
在多线程编程的领域中，死锁是一个让人头疼不已的问题。简单来说，死锁就是多个线程因为互相争夺资源，而陷入一种无限期的等待状态，导致所有线程都无法继续执行。就好比两个人过独木桥，独木桥一次只能容纳一个人通过，这两个人同时上了桥，一个从左边往右边走，另一个从右边往左边走，走到桥中间时，谁也不愿意退回去让对方先过，于是就僵持在那里，谁都无法到达对岸，这就是死锁在现实生活中的生动写照。在程序里，死锁通常发生在多个线程需要获取多个共享资源的时候。比如，线程 A 持有资源 1，并且想要获取资源 2；
gdb检测死锁
程序员的规则
09-26 428
gdb调试死锁
GDB排查死锁问题
微鉴道长的博客
08-23 1919
gdb排查死锁问题
GDB之死锁排查
tianyexing2008的博客
03-11 2935
多线程中遇到的常见“死锁”可能有两种情况：1，自身线程等锁（这个应该不叫死锁）；2，两个线程相互等对方的锁。 下面就两种情况分别举例：不管哪种情况，出现的时候首先查看函数调用栈，查找函数__lll_lock_wait。 1，本线程内等锁 出现这种情况一般是在一个函数里加锁了，在调用其他的函数里也加锁了，这样就像是嵌套加锁，导致卡死。 通过查看互斥锁变量值中的__owner可以得出，这个互斥锁所属线程为782，其实就是当前线程。我这个是在项目代码中模拟死锁加的代码。这是已经知道互斥锁变量名称的情况
linux多线程死锁问题分析
01-22
在分析死锁时，第一步通常是使用调试工具，如GDB (GNU Debugger) 来获取线程的堆栈信息。这里，开发者使用了`thread apply all bt`命令来查看所有线程的调用堆栈，这有助于找出哪个函数或者资源导致了死锁。从给出的...
Linux上分析死锁的简单方法(含运行代码)
j简说Linux的博客
02-18 876
本文简单介绍了一种在 Linux 平台下分析死锁问题的方法，对一些死锁问题的分析有一定作用。希望对大家有帮助。理解了死锁的原因，尤其是产生死锁的四个必要条件，就可以最大可能地避免、预防和解除死锁。所以，在系统设计、进程调度等方面注意如何不让这四个必要条件成立，如何确定资源的合理分配算法，避免进程永久占据系统资源。
gdb-6.7a.tar.gz_Linux Gdb调试
09-23
《Linux系统下的GDB调试与KGDB内核调试详解》 在Linux系统开发与维护过程中，调试工具扮演着至关重要的角色。本文将深入探讨两款重要的调试工具：GDB（GNU Debugger）和KGDB（Kernel GNU Debugger），它们是Linux...
gdb分析死锁
qq_41962968的博客
10-04 1001
Pn},其中P1等待P2占有的资源，P2等待P3占有的资源，…破坏“不可剥夺”条件：一个进程不能获得所需要的全部资源时便处于等待状态，等待期间他占有的资源将被隐式的释放重新加入到 系统的资源列表中，可以被其他的进程使用，而等待的进程只有重新获得自己原有的资源以及新申请的资源才可以重新启动，执行。破坏“循环等待”条件：采用资源有序分配其基本思想是将系统中的所有资源顺序编号，将紧缺的，稀少的采用较大的编号，在申请资源时必须按照编号的顺序进行，一个进程只有获得较小编号的进程才能申请较大编号的进程。
利用GDB分析死锁问题
sinat_32152141的博客
05-31 2022
互斥条件：资源是独占的且排他使用，进程互斥使用资源，即任意时刻一个资源只能给一个进程使用，其他进程若申请一个资源，而该资源被另一进程占有时，则申请者等待直到资源被占有者释放。 不可剥夺条件：进程所获得的资源在未使用完毕之前，不被其他进程强行剥夺，而只能由获得该资源的进程资源释放。 请求和保持条件：进程每次申请它所需要的一部分资源，在申请新的资源的同时，继续占用已分配到的资源。在发生死锁时必然存在一个进程等待队列{P1,P2,…,Pn},其中P1等待P2占有的资源，P2等待P3占有的资源，…，Pn等待P1占有
linux 上分析死锁的简单方法
horst Hu的专栏
08-12 2785
简介 死锁 (deallocks)： 是指两个或两个以上的进程（线程）在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程（线程）称为死锁进程（线程）。 由于资源占用是互斥的，当某个进程提出申请资源后，使得有关进程（线程）在无外力协助下，永远分配不到必需的资源而无法继续运行，这就产生了一种特殊
【Linux】线程安全：死锁（附加gdb调试分析）
Dooo_yh的博客
06-04 938
线程安全的死锁分析 gdb调试指令的展示
【操作系统】GDB 精确定位死锁位置技巧
Michael
04-19 1980
需要注意的是，如果程序中有多个线程同时等待同一个互斥锁，那么通过查看调用栈可能无法确定当前线程正在等待哪个互斥锁。此时，可以通过查看互斥锁的地址，以及在其他线程中调用。命令查看当前进程中所有线程的信息，包括线程 ID、状态、调用栈等信息。通过查看线程的调用栈，可以得知当前线程正在等待哪个互斥锁。找到当前正在运行的线程，并查看其调用栈。如果有，可以查看其参数，即可得知当前线程正在等待哪个互斥锁。函数的调用，可以查看其参数，即可得知当前线程正在等待哪个互斥锁。命令查看当前进程中所有线程的信息。
gdb定位死锁位置
qq_42370809的博客
06-22 949
使用gdb定位死锁的两种方法，差别在程序的调用上。
在linux上使用gdb分析死锁问题
qq_38993096的博客
05-20 259
学习1 学习2 死锁代码解读： #include<bits/stdc++.h> #include "unistd.h" using namespace std; pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t mutex3 = PTHREAD_MUTEX_INITIALIZER; pthread_mut
Linux多线程死锁案例：12线程中的4个互斥分析
在Linux多线程编程中，死锁...总结来说，Linux多线程死锁问题的分析关键在于识别并理解线程间的资源竞争和循环等待。通过细致的调用栈追踪和了解线程间交互，可以有效地定位和解决这类问题，以提升系统的稳定性和性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值