（学习笔记-进程管理）怎么避免死锁？-Toy模板网

这篇具有很好参考价值的文章主要介绍了（学习笔记-进程管理）怎么避免死锁？。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

死锁的概念

在多线程编程中，我们为了防止多线程竞争共享资源而导致数据错乱，都会在操作共享资源之前加上互斥锁，只有成功获得到锁的线程，才能操作共享资源，获取不到锁的线程就只能等待，直到锁被释放。

那么，当两个线程为了保护两个不同的共享资源而使用了两个互斥锁，那么这两个互斥锁应用不当的时候，可能会造成两个线程都在等待对方释放锁，在没有外力的作用下，这些次线程会一直相互等待，就没法继续运行，这种情况就是发生了死锁。

死锁必须同时满足以下四个条件才会发生：

互斥条件
持有并等待条件
不可剥夺条件
环路等待条件

互斥条件

互斥条件式指多个线程不能同时使用同一个资源。

eg：如果线程A已经持有的资源，不能同时被线程B持有，如果线程B请求获取线程A已经占用的资源，那线程B只能等待，直到线程A释放了资源。

（学习笔记-进程管理）怎么避免死锁？,操作系统,学习,笔记

持有并等待条件

持有并等待条件是指，当线程 A 已经持有了资源 1 ，又想申请资源 2 ，而资源 2 已经被线程 C 持有了，所以线程 A 就会处于等待状态，但是线程 A 在等待资源 2 的同时并不会释放在自己已经持有的资源 1 。

（学习笔记-进程管理）怎么避免死锁？,操作系统,学习,笔记

不可剥夺条件

不可剥夺条件是指，当线程已经持有了资源，在自己使用完之前不能被其他线程获取，线程 B 如果也想使用此资源，则只能在线程 A 使用完并释放后才能获取。

（学习笔记-进程管理）怎么避免死锁？,操作系统,学习,笔记

环路等待条件

环路等待条件是指，在死锁发生的时候，两个线程获取资源的顺序构成了环形链。

（学习笔记-进程管理）怎么避免死锁？,操作系统,学习,笔记

模拟死锁问题的产生

用代码来模拟死锁问题的产生。

首先，我们创建 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 的释放，双方都在等待对方资源的释放 -> 产生了死锁。

避免死锁问题的发生

前面说到，产生死锁的四个必要条件是：互斥条件、持有并等待条件、不可剥夺条件、环路等待条件。

那么避免死锁问题就只需要破坏其中一个条件就可以，最常见的并且可行的就是使用资源有序分配法，来破坏环路等待条件。

资源有序分配法：

线程 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;
}