我之前在项目里解决了一个死锁的问题，然后跟一个朋友聊了下，他让我深入研究一下这个问题。


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

forum.jpg


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


我们看下面的代码：

#include<pthread.h>
  • #include<string.h>
  • #include<errno.h>
  • #include<stdio.h>
  • #include<unistd.h>
  • pthread_mutex_t mutex;
  • int main()
  • {
  • pthread_mutex_init(&mutex,NULL);
  • printf("mutex init\n");
  • pthread_mutex_lock(&mutex);
  • printf("mutex lock#1\n");
  • pthread_mutex_lock(&mutex);
  • printf("mutex lock#2\n");
  • pthread_mutex_unlock(&mutex);
  • pthread_mutex_unlock(&mutex);
  • pthread_mutex_destroy(&mutex);
  • return 0;
  • }
    • 复制代码

    你看这样的代码会不会导致死锁呢？


    线程在上锁后，又马上继续尝试上锁，这样的情况会不会存在？


    类似这样的代码：

    int test_function(void)
  • {
  • //lock
  • do_something()
  • if(x) return -1
  • //unlock
  • }
    • 复制代码

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


    那么，如果是两个线程死锁的情况呢？

    #include <stdio.h>
  • #include <unistd.h>
  • #include <stdlib.h>
  • #include <pthread.h>
  • pthread_mutex_t g_mutex_lock;
  • pthread_mutex_t g_mutex_lock2;
  • void func1(void args)
  • {
  • printf("%s(),LINE=%d\n",__FUNCTION__,__LINE__);
  • pthread_mutex_lock(&g_mutex_lock);
  • sleep(1);
  • pthread_mutex_lock(&g_mutex_lock2);
  • printf("%s(),LINE=%d\n",__FUNCTION__,__LINE__);
  • pthread_mutex_unlock(&g_mutex_lock);
  • pthread_mutex_unlock(&g_mutex_lock2);
  • return NULL;
  • }
  • void func2(void args)
  • {
  • printf("%s(),LINE=%d\n",__FUNCTION__,__LINE__);
  • pthread_mutex_lock(&g_mutex_lock2);
  • sleep(1);
  • pthread_mutex_lock(&g_mutex_lock);
  • printf("%s(),LINE=%d\n",__FUNCTION__,__LINE__);
  • pthread_mutex_unlock(&g_mutex_lock2);
  • return NULL;
  • }
  • int main(void)
  • {
  • int ret;
  • pthread_t thread_1;
  • pthread_t thread_2;
  • printf("%s(),LINE=%d\n",__FUNCTION__,__LINE__);
  • ret = pthread_mutex_init(&g_mutex_lock, NULL);
  • if (ret != 0) {
  • printf("mutex init failed\n");
  • return -1;
  • }
  • ret = pthread_mutex_init(&g_mutex_lock2, NULL);
  • if (ret != 0) {
  • printf("mutex2 init failed\n");
  • return -1;
  • }
  • pthread_create(&thread_1, NULL, func1, NULL);
  • pthread_create(&thread_2, NULL, func2, NULL);
  • pthread_join(thread_1, NULL);
  • pthread_join(thread_2, NULL);
  • pthread_mutex_destroy(&g_mutex_lock);
  • pthread_mutex_destroy(&g_mutex_lock2);
  • printf("%s(),LINE=%d\n",__FUNCTION__,__LINE__);
  • return 0;
  • }
    • 复制代码

    上面的代码比较典型了。


    线程1拿到1号锁后，开始等待2号锁，线程2拿到2号锁后，就开始等待一号锁。他们属于互相等待的情况。


    代码输出：

  • linux@ubuntu:/study$ gcc argc.c -pthread && ./a.out
  • main(),LINE=37
  • func1(),LINE=11
  • func2(),LINE=23
    • 复制代码

    最后，线程出现死锁不会正常情况不会导致crash，除非代码上因为加锁存在的一些空指针。

    所以，单线程也是有可能导致死锁的。