关于操作系统:面试官什么是死锁怎么排查死锁怎么避免死锁

129次阅读

共计 7552 个字符,预计需要花费 19 分钟才能阅读完成。

忽然发现我的图解零碎缺了「死锁」的内容,这就来补下。

在面试过程中,死锁也是高频的考点,因为如果线上环境真多产生了死锁,那真的出小事了。

这次,咱们就来系统地聊聊死锁的问题。

  • 死锁的概念;
  • 模仿死锁问题的产生;
  • 利用工具排查死锁问题;
  • 防止死锁问题的产生;

死锁的概念

在多线程编程中,咱们为了避免多线程竞争共享资源而导致数据错乱,都会在操作共享资源之前加上互斥锁,只有胜利取得到锁的线程,能力操作共享资源,获取不到锁的线程就只能期待,直到锁被开释。

那么,当两个线程为了爱护两个不同的共享资源而应用了两个互斥锁,那么这两个互斥锁利用不当的时候,可能会造成 两个线程都在期待对方开释锁 ,在没有外力的作用下,这些线程会始终互相期待,就没方法持续运行,这种状况就是产生了 死锁

举个例子,小林拿了小美房间的钥匙,而小林在本人的房间里,小美拿了小林房间的钥匙,而小美也在本人的房间里。如果小林要从本人的房间里进来,必须拿到小美手中的钥匙,然而小美要进来,又必须拿到小林手中的钥匙,这就造成了死锁。

死锁只有 同时满足 以下四个条件才会产生:

  • 互斥条件;
  • 持有并期待条件;
  • 不可剥夺条件;
  • 环路期待条件;
互斥条件

互斥条件是指 多个线程不能同时应用同一个资源

比方下图,如果线程 A 曾经持有的资源,不能再同时被线程 B 持有,如果线程 B 申请获取线程 A 曾经占用的资源,那线程 B 只能期待,直到线程 A 开释了资源。

持有并期待条件

持有并期待条件是指,当线程 A 曾经持有了资源 1,又想申请资源 2,而资源 2 曾经被线程 C 持有了,所以线程 A 就会处于期待状态,然而 线程 A 在期待资源 2 的同时并不会开释本人曾经持有的资源 1

不可剥夺条件

不可剥夺条件是指,当线程曾经持有了资源,在本人应用完之前不能被其余线程获取,线程 B 如果也想应用此资源,则只能在线程 A 应用完并开释后能力获取。

环路期待条件

环路期待条件指都是,在死锁产生的时候,两个线程获取资源的程序形成了环形链

比方,线程 A 曾经持有资源 2,而想申请资源 1,线程 B 曾经获取了资源 1,而想申请资源 2,这就造成资源申请期待的环形图。


模仿死锁问题的产生

Talk is cheap. Show me the code.

上面,咱们用代码来模仿死锁问题的产生。

首先,咱们先创立 2 个线程,别离为线程 A 和 线程 B,而后有两个互斥锁,别离是 mutex_A 和 mutex_B,代码如下:

pthread_mutex_t mutex_A = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_B = PTHREAD_MUTEX_INITIALIZER;

int main()
{
    pthread_t tidA, tidB;
    
    // 创立两个线程
    pthread_create(&tidA, NULL, threadA_proc, NULL);
    pthread_create(&tidB, NULL, threadB_proc, NULL);
    
    pthread_join(tidA, NULL);
    pthread_join(tidB, NULL);
    
    printf("exit\n");
    
    return 0;
}

接下来,咱们看下线程 A 函数做了什么。

// 线程函数 A
void *threadA_proc(void *data)
{printf("thread A waiting get ResourceA \n");
    pthread_mutex_lock(&mutex_A);
    printf("thread A got ResourceA \n");
    
    sleep(1);
    
    printf("thread A waiting get ResourceB \n");
    pthread_mutex_lock(&mutex_B);
    printf("thread A got ResourceB \n");

    pthread_mutex_unlock(&mutex_B);
    pthread_mutex_unlock(&mutex_A);
    return (void *)0;
}

能够看到,线程 A 函数的过程:

  • 先获取互斥锁 A,而后睡眠 1 秒;
  • 再获取互斥锁 B,而后开释互斥锁 B;
  • 最初开释互斥锁 A;
// 线程函数 B
void *threadB_proc(void *data)
{printf("thread B waiting get ResourceB \n");
    pthread_mutex_lock(&mutex_B);
    printf("thread B got ResourceB \n");
    
    sleep(1);
    
    printf("thread B waiting  get ResourceA \n");
    pthread_mutex_lock(&mutex_A);
    printf("thread B got ResourceA \n");
    
    pthread_mutex_unlock(&mutex_A);
    pthread_mutex_unlock(&mutex_B);
    return (void *)0;
}

能够看到,线程 B 函数的过程:

  • 先获取互斥锁 B,而后睡眠 1 秒;
  • 再获取互斥锁 A,而后开释互斥锁 A;
  • 最初开释互斥锁 B;

而后,咱们运行这个程序,运行后果如下:

thread B waiting get ResourceB 
thread B got ResourceB 
thread A waiting get ResourceA 
thread A got ResourceA 
thread B waiting get ResourceA 
thread A waiting get ResourceB 
// 阻塞中。。。

能够看到线程 B 在期待互斥锁 A 的开释,线程 A 在期待互斥锁 B 的开释,单方都在期待对方资源的开释,很显著,产生了死锁问题。


利用工具排查死锁问题

如果你想排查你的 Java 程序是否死锁,则能够应用 jstack 工具,它是 jdk 自带的线程堆栈剖析工具。

因为小林的死锁代码例子是 C 写的,在 Linux 下,咱们能够应用 pstack + gdb 工具来定位死锁问题。

pstack 命令能够显示每个线程的栈跟踪信息(函数调用过程),它的应用形式也很简略,只须要 pstack <pid> 就能够了。

那么,在定位死锁问题时,咱们能够屡次执行 pstack 命令查看线程的函数调用过程,屡次比照后果,确认哪几个线程始终没有变动,且是因为在期待锁,那么大概率是因为死锁问题导致的。

我用 pstack 输入了我后面模仿死锁问题的过程的所有线程的状况,我屡次执行命令后,其后果都一样,如下:

$ pstack 87746
Thread 3 (Thread 0x7f60a610a700 (LWP 87747)):
#0  0x0000003720e0da1d in __lll_lock_wait () from /lib64/libpthread.so.0
#1  0x0000003720e093ca in _L_lock_829 () from /lib64/libpthread.so.0
#2  0x0000003720e09298 in pthread_mutex_lock () from /lib64/libpthread.so.0
#3  0x0000000000400725 in threadA_proc ()
#4  0x0000003720e07893 in start_thread () from /lib64/libpthread.so.0
#5  0x00000037206f4bfd in clone () from /lib64/libc.so.6
Thread 2 (Thread 0x7f60a5709700 (LWP 87748)):
#0  0x0000003720e0da1d in __lll_lock_wait () from /lib64/libpthread.so.0
#1  0x0000003720e093ca in _L_lock_829 () from /lib64/libpthread.so.0
#2  0x0000003720e09298 in pthread_mutex_lock () from /lib64/libpthread.so.0
#3  0x0000000000400792 in threadB_proc ()
#4  0x0000003720e07893 in start_thread () from /lib64/libpthread.so.0
#5  0x00000037206f4bfd in clone () from /lib64/libc.so.6
Thread 1 (Thread 0x7f60a610c700 (LWP 87746)):
#0  0x0000003720e080e5 in pthread_join () from /lib64/libpthread.so.0
#1  0x0000000000400806 in main ()

....

$ pstack 87746
Thread 3 (Thread 0x7f60a610a700 (LWP 87747)):
#0  0x0000003720e0da1d in __lll_lock_wait () from /lib64/libpthread.so.0
#1  0x0000003720e093ca in _L_lock_829 () from /lib64/libpthread.so.0
#2  0x0000003720e09298 in pthread_mutex_lock () from /lib64/libpthread.so.0
#3  0x0000000000400725 in threadA_proc ()
#4  0x0000003720e07893 in start_thread () from /lib64/libpthread.so.0
#5  0x00000037206f4bfd in clone () from /lib64/libc.so.6
Thread 2 (Thread 0x7f60a5709700 (LWP 87748)):
#0  0x0000003720e0da1d in __lll_lock_wait () from /lib64/libpthread.so.0
#1  0x0000003720e093ca in _L_lock_829 () from /lib64/libpthread.so.0
#2  0x0000003720e09298 in pthread_mutex_lock () from /lib64/libpthread.so.0
#3  0x0000000000400792 in threadB_proc ()
#4  0x0000003720e07893 in start_thread () from /lib64/libpthread.so.0
#5  0x00000037206f4bfd in clone () from /lib64/libc.so.6
Thread 1 (Thread 0x7f60a610c700 (LWP 87746)):
#0  0x0000003720e080e5 in pthread_join () from /lib64/libpthread.so.0
#1  0x0000000000400806 in main ()

能够看到,Thread 2 和 Thread 3 始终阻塞获取锁(pthread_mutex_lock)的过程,而且 pstack 屡次输入信息都没有变动,那么可能大概率产生了死锁。

然而,还不可能确认这两个线程是在相互期待对方的锁的开释,因为咱们看不到它们是等在哪个锁对象,于是咱们能够应用 gdb 工具进一步确认。

整个 gdb 调试过程,如下:

// gdb 命令
$ gdb -p 87746

// 打印所有的线程信息
(gdb) info thread
  3 Thread 0x7f60a610a700 (LWP 87747)  0x0000003720e0da1d in __lll_lock_wait () from /lib64/libpthread.so.0
  2 Thread 0x7f60a5709700 (LWP 87748)  0x0000003720e0da1d in __lll_lock_wait () from /lib64/libpthread.so.0
* 1 Thread 0x7f60a610c700 (LWP 87746)  0x0000003720e080e5 in pthread_join () from /lib64/libpthread.so.0
// 最右边的 * 示意 gdb 锁定的线程,切换到第二个线程去查看

// 切换到第 2 个线程
(gdb) thread 2
[Switching to thread 2 (Thread 0x7f60a5709700 (LWP 87748))]#0  0x0000003720e0da1d in __lll_lock_wait () from /lib64/libpthread.so.0 

// bt 能够打印函数堆栈,却无奈看到函数参数,跟 pstack 命令一样 
(gdb) bt
#0  0x0000003720e0da1d in __lll_lock_wait () from /lib64/libpthread.so.0
#1  0x0000003720e093ca in _L_lock_829 () from /lib64/libpthread.so.0
#2  0x0000003720e09298 in pthread_mutex_lock () from /lib64/libpthread.so.0
#3  0x0000000000400792 in threadB_proc (data=0x0) at dead_lock.c:25
#4  0x0000003720e07893 in start_thread () from /lib64/libpthread.so.0
#5  0x00000037206f4bfd in clone () from /lib64/libc.so.6

// 打印第三帧信息,每次函数调用都会有压栈的过程,而 frame 则记录栈中的帧信息
(gdb) frame 3
#3  0x0000000000400792 in threadB_proc (data=0x0) at dead_lock.c:25
27    printf("thread B waiting get ResourceA \n");
28    pthread_mutex_lock(&mutex_A);

// 打印 mutex_A 的值 ,  __owner 示意 gdb 中标示线程的值,即 LWP
(gdb) p mutex_A
$1 = {__data = {__lock = 2, __count = 0, __owner = 87747, __nusers = 1, __kind = 0, __spins = 0, __list = {__prev = 0x0, __next = 0x0}}, 
  __size = "\002\000\000\000\000\000\000\000\303V\001\000\001", '\000' <repeats 26 times>, __align = 2}

// 打印 mutex_B 的值 ,  __owner 示意 gdb 中标示线程的值,即 LWP
(gdb) p mutex_B
$2 = {__data = {__lock = 2, __count = 0, __owner = 87748, __nusers = 1, __kind = 0, __spins = 0, __list = {__prev = 0x0, __next = 0x0}}, 
  __size = "\002\000\000\000\000\000\000\000\304V\001\000\001", '\000' <repeats 26 times>, __align = 2}  

我来解释下,下面的调试过程:

  1. 通过 info thread 打印了所有的线程信息,能够看到有 3 个线程,一个是主线程(LWP 87746),另外两个都是咱们本人创立的线程(LWP 87747 和 87748);
  2. 通过 thread 2,将切换到第 2 个线程(LWP 87748);
  3. 通过 bt,打印线程的调用栈信息,能够看到有 threadB_proc 函数,阐明这个是线程 B 函数,也就说 LWP 87748 是线程 B;
  4. 通过 frame 3,打印调用栈中的第三个帧的信息,能够看到线程 B 函数,在获取互斥锁 A 的时候阻塞了;
  5. 通过 p mutex_A,打印互斥锁 A 对象信息,能够看到它被 LWP 为 87747(线程 A)的线程持有着;
  6. 通过 p mutex_B,打印互斥锁 A 对象信息,能够看到他被 LWP 为 87748(线程 B)的线程持有着;

因为线程 B 在期待线程 A 所持有的 mutex_A, 而同时线程 A 又在期待线程 B 所领有的 mutex_B, 所以能够判定该程序产生了死锁。


防止死锁问题的产生

后面咱们提到,产生死锁的四个必要条件是:互斥条件、持有并期待条件、不可剥夺条件、环路期待条件。

那么防止死锁问题就只须要破环其中一个条件就能够,最常见的并且可行的就是 应用资源有序调配法,来破环环路期待条件

那什么是资源有序调配法呢?

线程 A 和 线程 B 获取资源的程序要一样,当线程 A 是先尝试获取资源 A,而后尝试获取资源 B 的时候,线程 B 同样也是先尝试获取资源 A,而后尝试获取资源 B。也就是说,线程 A 和 线程 B 总是以雷同的程序申请本人想要的资源。

咱们应用资源有序调配法的形式来批改后面产生死锁的代码,咱们能够不改变线程 A 的代码。

咱们先要分明线程 A 获取资源的程序,它是先获取互斥锁 A,而后获取互斥锁 B。

所以咱们只需将线程 B 改成以雷同程序的获取资源,就能够突破死锁了。

线程 B 函数改良后的代码如下:

// 线程 B 函数,同线程 A 一样,先获取互斥锁 A,而后获取互斥锁 B
void *threadB_proc(void *data)
{printf("thread B waiting get ResourceA \n");
    pthread_mutex_lock(&mutex_A);
    printf("thread B got ResourceA \n");
    
    sleep(1);
    
    printf("thread B waiting  get ResourceB \n");
    pthread_mutex_lock(&mutex_B);
    printf("thread B got ResourceB \n");
    
    pthread_mutex_unlock(&mutex_B);
    pthread_mutex_unlock(&mutex_A);
    return (void *)0;
}

执行后果如下,能够看,没有产生死锁。

thread B waiting get ResourceA 
thread B got ResourceA 
thread A waiting get ResourceA 
thread B waiting  get ResourceB 
thread B got ResourceB 
thread A got ResourceA 
thread A waiting get ResourceB 
thread A got ResourceB
exit

总结

简略来说,死锁问题的产生是由两个或者以上线程并行执行的时候,抢夺资源而相互期待造成的。

死锁只有同时满足互斥、持有并期待、不可剥夺、环路期待这四个条件的时候才会产生。

所以要防止死锁问题,就是要毁坏其中一个条件即可,最罕用的办法就是应用资源有序调配法来毁坏环路期待条件。

正文完
 0