单线程会导致死锁你知道吗

小小的狮

死锁从文字理论上说明的是两个线程，可以认为是两个人A和B，A在等待B完成某件事情，B又在等待A完成某件事情。

那如果在代码中，单线程的某个函数，有没有可能导致死锁呢？
我们看下面的代码

1. #include<pthread.h>
   
2. #include<string.h>
   
3. #include<errno.h>
   
4. #include<stdio.h>
   
5. #include<unistd.h>
   
6. pthread_mutex_t mutex;
   
7. int main()
   
8. {
   
9.     pthread_mutex_init(&mutex,NULL);
   
10.     printf("mutex init\n");
    
11.     pthread_mutex_lock(&mutex);
    
12.     printf("mutex lock#1\n");
    
13.     pthread_mutex_lock(&mutex);
    
14.     printf("mutex lock#2\n");
    
15.     pthread_mutex_unlock(&mutex);
    
16.     pthread_mutex_unlock(&mutex);
    
17.     pthread_mutex_destroy(&mutex);
    
18.     return 0;
    
19. }

复制代码

你看这样的代码会不会导致死锁呢？
线程在上锁后，又马上继续尝试上锁，这样的情况会不会存在？
类似这样的代码

1. int test_function(void)
   
2. {
   
3.   //lock
   
4.   do_something()
   
5.   if(x) return -1
   
6.   //unlock
   
7. }

复制代码

在上锁后，然后下面会因为某种判断后退出，下一次进来后，又会进行上锁，这样的死锁是因为代码逻辑不正确导致的，也是很多新手常犯的问题。
如果是两个线程死锁的情况呢？

1. #include <stdio.h>
   
2. #include <unistd.h>
   
3. #include <stdlib.h>
   
4. #include <pthread.h>
   
5. pthread_mutex_t g_mutex_lock;
   
6. pthread_mutex_t g_mutex_lock2;
   
7. void *func1(void* args)
   
8. {
   
9.     printf("%s(),LINE=%d\n",__FUNCTION__,__LINE__);
   
10.     pthread_mutex_lock(&g_mutex_lock);
    
11.     sleep(1);
    
12.     pthread_mutex_lock(&g_mutex_lock2);
    
13.     printf("%s(),LINE=%d\n",__FUNCTION__,__LINE__);
    
14.     pthread_mutex_unlock(&g_mutex_lock);
    
15.     pthread_mutex_unlock(&g_mutex_lock2);
    
16.     return NULL;
    
17. }
    
18. void *func2(void* args)
    
19. {
    
20.     printf("%s(),LINE=%d\n",__FUNCTION__,__LINE__);
    
21.     pthread_mutex_lock(&g_mutex_lock2);
    
22.     sleep(1);
    
23.     pthread_mutex_lock(&g_mutex_lock);
    
24.     printf("%s(),LINE=%d\n",__FUNCTION__,__LINE__);
    
25.     pthread_mutex_unlock(&g_mutex_lock2);
    
26.     return NULL;
    
27. }
    
28. int main(void)
    
29. {
    
30.     int ret;
    
31.     pthread_t thread_1;
    
32.     pthread_t thread_2;
    
33.     printf("%s(),LINE=%d\n",__FUNCTION__,__LINE__);
    
34.     ret = pthread_mutex_init(&g_mutex_lock, NULL);
    
35.     if (ret != 0) {
    
36.         printf("mutex init failed\n");
    
37.         return -1;
    
38.     }
    
39.     ret = pthread_mutex_init(&g_mutex_lock2, NULL);
    
40.     if (ret != 0) {
    
41.         printf("mutex2 init failed\n");
    
42.         return -1;
    
43.     }
    
44.     pthread_create(&thread_1, NULL, func1, NULL);
    
45.     pthread_create(&thread_2, NULL, func2, NULL);
    
46.     pthread_join(thread_1, NULL);
    
47.     pthread_join(thread_2, NULL);
    
48.     pthread_mutex_destroy(&g_mutex_lock);
    
49.     pthread_mutex_destroy(&g_mutex_lock2);
    
50.     printf("%s(),LINE=%d\n",__FUNCTION__,__LINE__);
    
51.     return 0;
    
52. }

复制代码

上面的代码比较典型了
线程1拿到1号锁后，开始等待2号锁，线程2拿到2号锁后，就开始等待一号锁。他们属于互相等待的情况。
代码输出

1. linux@ubuntu:/study$ gcc argc.c -pthread && ./a.outmain(),LINE=37func1(),LINE=11func2(),LINE=23

复制代码

最后，线程出现死锁不会正常情况不会导致crash，除非代码上因为加锁存在的一些空指针。
所以单线程也是有可能导致死锁的。
总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注晓枫资讯的更多内容!   

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

马玺Maxi

感谢楼主，顶。

轻浮浮夸轻o

路过，支持一下

zzzmhakyjk

顶顶更健康！！！