一个 Linux 上分析死锁的简单方法（1）

论坛元老

Rank: 8 Rank: 8

UID: 1066743

1^#

打印

字体大小: tT

look_w发表于 2018-4-22 16:14 | 只看该作者

一个 Linux 上分析死锁的简单方法（1）

简介死锁 (deallocks)：是指两个或两个以上的进程（线程）在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程（线程）称为死锁进程（线程）。由于资源占用是互斥的，当某个进程提出申请资源后，使得有关进程（线程）在无外力协助下，永远分配不到必需的资源而无法继续运行，这就产生了一种特殊现象死锁。
一种交叉持锁死锁的情形，此时执行程序中两个或多个线程发生永久堵塞（等待），每个线程都在等待被其它线程占用并堵塞了的资源。例如，如果线程 1 锁住了记录 A 并等待记录 B，而线程 2 锁住了记录 B 并等待记录 A，这样两个线程就发生了死锁现象。在计算机系统中 , 如果系统的资源分配策略不当，更常见的可能是程序员写的程序有错误等，则会导致进程因竞争资源不当而产生死锁的现象。
产生死锁的四个必要条件（1）互斥条件：一个资源每次只能被一个进程（线程）使用。
（2）请求与保持条件：一个进程（线程）因请求资源而阻塞时，对已获得的资源保持不放。
（3）不剥夺条件 : 此进程（线程）已获得的资源，在末使用完之前，不能强行剥夺。
（4）循环等待条件 : 多个进程（线程）之间形成一种头尾相接的循环等待资源关系。
图 1. 交叉持锁的死锁示意图：

注释：在执行 func2 和 func4 之后，子线程 1 获得了锁 A，正试图获得锁 B，但是子线程 2 此时获得了锁 B，正试图获得锁 A，所以子线程 1 和子线程 2 将没有办法得到锁 A 和锁 B，因为它们各自被对方占有，永远不会释放，所以发生了死锁的现象。
使用 pstack 和 gdb 工具对死锁程序进行分析pstack 在 Linux 平台上的简单介绍pstack 是 Linux（比如 Red Hat Linux 系统、Ubuntu Linux 系统等）下一个很有用的工具，它的功能是打印输出此进程的堆栈信息。可以输出所有线程的调用关系栈。
gdb 在 Linux 平台上的简单介绍GDB 是 GNU 开源组织发布的一个强大的 UNIX 下的程序调试工具。Linux 系统中包含了 GNU 调试程序 gdb，它是一个用来调试 C 和 C++ 程序的调试器。可以使程序开发者在程序运行时观察程序的内部结构和内存的使用情况 .
gdb 所提供的一些主要功能如下所示：
   1 运行程序，设置能影响程序运行的参数和环境 ;
   2 控制程序在指定的条件下停止运行；
   3 当程序停止时，可以检查程序的状态；
   4 当程序 crash 时，可以检查 core 文件；
   5 可以修改程序的错误，并重新运行程序；
   6 可以动态监视程序中变量的值；
   7 可以单步执行代码，观察程序的运行状态。
gdb 程序调试的对象是可执行文件或者进程，而不是程序的源代码文件。然而，并不是所有的可执行文件都可以用 gdb 调试。如果要让产生的可执行文件可以用来调试，需在执行 g++（gcc）指令编译程序时，加上 -g 参数，指定程序在编译时包含调试信息。调试信息包含程序里的每个变量的类型和在可执行文件里的地址映射以及源代码的行号。gdb 利用这些信息使源代码和机器码相关联。gdb 的基本命令较多，不做详细介绍，大家如果需要进一步了解，请参见 gdb 手册。
清单 1. 测试程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

#include <unistd.h>
#include <pthread.h>
#include <string.h>

pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex3 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex4 = PTHREAD_MUTEX_INITIALIZER;

static int sequence1 = 0;
static int sequence2 = 0;

int func1()
{
pthread_mutex_lock(&mutex1);
++sequence1;
sleep(1);
pthread_mutex_lock(&mutex2);
++sequence2;
pthread_mutex_unlock(&mutex2);
pthread_mutex_unlock(&mutex1);

return sequence1;
}

int func2()
{
pthread_mutex_lock(&mutex2);
++sequence2;
sleep(1);
pthread_mutex_lock(&mutex1);
++sequence1;
pthread_mutex_unlock(&mutex1);
pthread_mutex_unlock(&mutex2);

return sequence2;
}

void* thread1(void* arg)
{
while (1)
{
   int iRetValue = func1();

   if (iRetValue == 100000)
   {
         pthread_exit(NULL);
   }
}
}

void* thread2(void* arg)
{
while (1)
{
   int iRetValue = func2();

   if (iRetValue == 100000)
   {
         pthread_exit(NULL);
   }
}
}

void* thread3(void* arg)
{
while (1)
{
   sleep(1);
   char szBuf[128];
   memset(szBuf, 0, sizeof(szBuf));
   strcpy(szBuf, "thread3");
}
}

void* thread4(void* arg)
{
while (1)
{
   sleep(1);
   char szBuf[128];
   memset(szBuf, 0, sizeof(szBuf));
   strcpy(szBuf, "thread3");
}
}

int main()
{
pthread_t tid[4];
if (pthread_create(&tid[0], NULL, &thread1, NULL) != 0)
{
   _exit(1);
}
if (pthread_create(&tid[1], NULL, &thread2, NULL) != 0)
{
   _exit(1);
}
if (pthread_create(&tid[2], NULL, &thread3, NULL) != 0)
{
   _exit(1);
}
if (pthread_create(&tid[3], NULL, &thread4, NULL) != 0)
{
   _exit(1);
}

sleep(5);
//pthread_cancel(tid[0]);

pthread_join(tid[0], NULL);
pthread_join(tid[1], NULL);
pthread_join(tid[2], NULL);
pthread_join(tid[3], NULL);

pthread_mutex_destroy(&mutex1);
pthread_mutex_destroy(&mutex2);
pthread_mutex_destroy(&mutex3);
pthread_mutex_destroy(&mutex4);

return 0;
}

清单 2. 编译测试程序

1	[dyu@xilinuxbldsrv purify]$ g++ -g lock.cpp -o lock -lpthread

清单 3. 查找测试程序的进程号

1 2	[dyu@xilinuxbldsrv purify]$ ps -ef\|grep lock dyu 6721 5751 0 15:21 pts/3 00:00:00 ./lock

收藏分享评分

回复引用

订阅 TOP

返回列表