十四、Linux下线程的死锁_linux3.14应用程序线程假死-CSDN博客

本文链接：https://blog.csdn.net/qq_42169059/article/details/92770319

一、死锁的概念

一般情况下,如果同一个线程先后两次调用lock，在第一次调用时，由于锁已经被占,该线程会挂起等待别的线程释放锁,然而锁正是被自己占着的，该线程又被挂起，没有机会释放锁,因此，就永远处于挂起等待状态了，这叫做死锁(Deadlock)。
另种典型的死锁情形是这样:线程A获得了锁1，线程B获得了锁2，这时线程A调用lock试图获得锁2,结果是需要挂起等待线程B释放锁2，而这时线程B也调用lock试图获得锁1，结果是需要挂起等待线程A释放锁1，于是线程A和B都永远处于挂起状态了。

举例说明：你的家里的钥匙，你给父母了一把，自己留一把。你父母家的钥匙，父母给你一把，他们自己留了一把。假如某一天，你出门的时候忘记带钥匙了，自己的和父母的钥匙都锁在家里了。凑巧的是，你父母家里的门同样锁了，父母的钥匙和你家的钥匙也都被锁了。你们两家手里都没有了钥匙，谁也不能开自家的门，和对方的门，这样就出现了死锁的现象，只能叫解锁公司来解锁。

所谓死锁，是指多个线程在运行过程中因争夺资源而造成的一种僵局(DeadlyEmbreace)即互相等待的现象，当线程处于这种僵持状态时，若无外力作用，它们都将无法向前推进。

二、死锁产生的原因

系统资源的竞争
通常系统中拥有的不可剥夺资源，其数量不足以满足多个进程运行的需要，使得进程在运行过程中，会因争夺资源而陷入僵局，如磁带机、打印机等。只有对不可剥夺资源的竞争才可能产生死锁，对可剥夺资源的竞争是不会引起死锁的。
进程推进顺序非法
进程在运行过程中，请求和释放资源的顺序不当，也同样会导致死锁。例如，并发进程 P1、P2分别保持了资源R1、R2，而进程P1申请资源R2，进程P2申请资源R1时，两者都会因为所需资源被占用而阻塞。

信号量使用不当也会造成死锁。进程间彼此相互等待对方发来的消息，结果也会使得这些进程间无法继续向前推进。例如，进程A等待进程B发的消息，进程B又在等待进程A 发的消息，可以看出进程A和B不是因为竞争同一资源，而是在等待对方的资源导致死锁。

三、死锁产生的必要条件

虽然线程在运行过程中可能发生死锁，但死锁的发生也必须具备一定的条件。死锁的发生必须具备下列四个必要条件。

互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。
请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。
不剥夺条件：指进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。
环路等待条件：指在发生死锁时，必然存在一个进程——资源的环形链，即进程集合{P0，P1，P2，···，Pn}中的P0正在等待一个P1占用的资源；P1正在等待P2占用的资源，……，Pn正在等待已被P0占用的资源。

四、死锁的预防方法

在有些情况下死锁是可以避免的。用于避免死锁的技术：

加锁顺序（线程按照一定的顺序加锁即按相同的次序锁定相应的共享资源）
加锁时限（线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该锁的请求，并释放自己占有的锁）使用函数 pthread_mutex_trylock()，它是函数 pthread_mutex_lock() 的非阻塞版本。

五、死锁的案例

典型的死锁情形是这样:线程A获得了锁1，线程B获得了锁2，这时线程A调用lock试图获得锁2,结果是需要挂起等待线程B释放锁2，而这时线程B也调用lock试图获得锁1，结果是需要挂起等待线程A释放锁1，于是线程A和B都永远处于挂起状态了。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

/*定义两个共享资源*/
typedef struct
{
        int ResultA;
        pthread_mutex_t A_Lock;
}ResourceA;

typedef struct
{
        int ResultB;
        pthread_mutex_t B_Lock;
}ResourceB;
/*定义储存的结构体*/
typedef struct
{
        ResourceA *ra;
        ResourceB *rb;
}Storage;
/*定义两个线程并按照不同的顺序进行上锁*/
void* a_fn(void* arg)
{
        Storage* s=(Storage*)arg;
        //对资源A进行加锁
        pthread_mutex_lock(&s->ra->A_Lock);
        sleep(1);
        printf("0x%lx is waiting ResourceB...\r\n",pthread_self());
        //对资源B进行加锁
        pthread_mutex_lock(&s->rb->B_Lock);
        printf("ResourceA value=%d\r\n",s->ra->ResultA);
        printf("ResourceB value=%d\r\n",s->rb->ResultB);
        //对资源AB进行解锁
        pthread_mutex_unlock(&s->ra->A_Lock);
        pthread_mutex_unlock(&s->rb->B_Lock);
        return 0;
}
void* b_fn(void* arg)
{
        Storage* s=(Storage*)arg;
        //对资源B进行加锁
        pthread_mutex_lock(&s->rb->B_Lock);
        sleep(1);
        printf("0x%lx is waiting ResourceA...\r\n",pthread_self());
        //对资源A进行加锁
        pthread_mutex_lock(&s->ra->A_Lock);
        printf("ResourceA value=%d\r\n",s->ra->ResultA);
        printf("ResourceB value=%d\r\n",s->rb->ResultB);
        //对资源AB进行解锁
        pthread_mutex_unlock(&s->ra->A_Lock);
        pthread_mutex_unlock(&s->rb->B_Lock);
        return 0;
}
int main()
{
        int err;
        pthread_t thread_a,thread_b;
        ResourceA ra;
        ResourceB rb;
        Storage s={&ra,&rb};
        ra.ResultA=100;
        rb.ResultB=200;
        /*初始化两互斥锁*/
        pthread_mutex_init(&ra.A_Lock,NULL);
        pthread_mutex_init(&rb.B_Lock,NULL);
        /*创建两个线程函数*/
        if((err=pthread_create(&thread_a,NULL,a_fn,(void*)&s))!=0)
        {
                printf("thread_a create fail\r\n");
        }
        if((err=pthread_create(&thread_b,NULL,b_fn,(void*)&s))!=0)
        {
                printf("thread_b create fail\r\n");
        }
        /*阻塞两线程*/
        pthread_join(thread_a,NULL);
        pthread_join(thread_b,NULL);

        /*销毁两个互斥锁*/
        pthread_mutex_destroy(&ra.A_Lock);
        pthread_mutex_destroy(&rb.B_Lock);

        return 0;
}

从以上程序来分析，线程a先使用A锁对A的共享资源进行了加锁，睡眠的1s运行了B线程，B线程使用了B锁对B的共享资源进行了加锁。当线程A运行到要对B锁加锁时，由于线程B已经使用了B锁加锁了线程B共享资源，造成A线程一直阻塞在哪里。线程B运行到要使用A锁对线程资源进行加锁，由于A线程已经使用了A锁对共享资源进行加锁，造成了B线程的A锁一直阻塞在哪里。这种互相等待的现象，这样的情况就造成了死锁的现象。
在这里插入图片描述
解决方法：按照线程加锁顺序进行加锁。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

/*定义两个共享资源*/
typedef struct
{
        int ResultA;
        pthread_mutex_t A_Lock;
}ResourceA;

typedef struct
{
        int ResultB;
        pthread_mutex_t B_Lock;
}ResourceB;
/*定义储存的结构体*/
typedef struct
{
        ResourceA *ra;
        ResourceB *rb;
}Storage;
/*定义两个线程并按照不同的顺序进行上锁*/
void* a_fn(void* arg)
{
        Storage* s=(Storage*)arg;
        //对资源A进行加锁
        pthread_mutex_lock(&s->ra->A_Lock);
        sleep(1);
        printf("0x%lx is waiting ResourceB...\r\n",pthread_self());
        //对资源B进行加锁
        pthread_mutex_lock(&s->rb->B_Lock);
        printf("ResourceA value=%d\r\n",s->ra->ResultA);
        printf("ResourceB value=%d\r\n",s->rb->ResultB);
        //对资源AB进行解锁
        pthread_mutex_unlock(&s->ra->A_Lock);
        pthread_mutex_unlock(&s->rb->B_Lock);
        return 0;
}
void* b_fn(void* arg)
{
        Storage* s=(Storage*)arg;
        //对资源B进行加锁
        pthread_mutex_lock(&s->ra->A_Lock);
        sleep(1);
        printf("0x%lx is waiting ResourceA...\r\n",pthread_self());
        //对资源A进行加锁
        pthread_mutex_lock(&s->rb->B_Lock);
        printf("ResourceA value=%d\r\n",s->ra->ResultA);
        printf("ResourceB value=%d\r\n",s->rb->ResultB);
        //对资源AB进行解锁
        pthread_mutex_unlock(&s->ra->A_Lock);
        pthread_mutex_unlock(&s->rb->B_Lock);
        return 0;
}
int main()
{
        int err;
        pthread_t thread_a,thread_b;
        ResourceA ra;
        ResourceB rb;
        Storage s={&ra,&rb};
        ra.ResultA=100;
        rb.ResultB=200;
        /*初始化两互斥锁*/
        pthread_mutex_init(&ra.A_Lock,NULL);
        pthread_mutex_init(&rb.B_Lock,NULL);
        /*创建两个线程函数*/
        if((err=pthread_create(&thread_a,NULL,a_fn,(void*)&s))!=0)
        {
                printf("thread_a create fail\r\n");
        }
        if((err=pthread_create(&thread_b,NULL,b_fn,(void*)&s))!=0)
        {
                printf("thread_b create fail\r\n");
        }
        /*阻塞两线程*/
        pthread_join(thread_a,NULL);
        pthread_join(thread_b,NULL);

        /*销毁两个互斥锁*/
        pthread_mutex_destroy(&ra.A_Lock);
        pthread_mutex_destroy(&rb.B_Lock);

        return 0;
}

在这里插入图片描述