单线程会导致死锁吗?

嵌入式Linux

共 2484字,需浏览 5分钟

 ·

2022-02-12 21:28

我之前在我们的项目里面解决了一个死锁的问题,然后我跟一个我的朋友聊了下,他让我深入研究下这个问题。大家也可以考虑想我的这个问题。


首先我们再看看什么是死锁?


什么是死锁

用个通俗的例子讲一讲死锁


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




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


我们看下面的代码



#include
#include
#include
#include
#include
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 
#include 
#include 
#include 

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,除非代码上因为加锁存在的一些空指针。


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



浏览 32
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报
评论
图片
表情
推荐
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报