死锁: 指多个进程/线程并发执行中,由于争抢资源而造成的阻塞现象。
产生死锁的必要条件:
1.互斥:进程请求的资源是临界资源
2.请求并保持:进程占有了资源,并同时请求其他资源
3.不可剥夺条件:进程占有的资源在未使用完之前,不可被剥夺
4.环路等待
解决死锁的方法:
预防死锁: 破坏产生死锁的条件
资源一次性分配：一次性分配所有资源，这样就不会再有请求了：（破坏请求条件）
只要有一个资源得不到分配，也不给这个进程分配其他的资源：（破坏请保持条件）
可剥夺资源：即当某进程获得了部分资源，但得不到其它资源，则释放已占有的资源（破坏不可剥夺条件）
资源有序分配法：系统给每类资源赋予一个编号，每一个进程按编号递增的顺序请求资源，释放则相反（破坏环路等待条件）
1.代码上预防死锁: 保证顺序加锁,比较mutex对象地址,始终先加锁地址比较小的
2.使用超时放弃机制
避免死锁: 银行家算法
预防死锁的方法严重影响OS性能,所以使用银行家算法避免死锁。
银行家算法:
(1) 可利用资源向量Available。这是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目。
(2) 最大需求矩阵Max。这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。
(3) 分配矩阵Allocation。这也是一个n×m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。
(4) 需求矩阵Need。这也是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数。
上述三个矩阵间存在下述关系：Allocation[i,j] + Need[i, j] = Max[i, j]
OS按照银行家制定的规则为进程分配资源 --- 1.请求是否可以分配(<Max,<Avai) 2.分配资源,用安全性算法检测
设Requesti是进程Pi的请求向量，如果Requesti[j]=K，表示进程Pi需要K个R j类型的资源。当Pi发出资源请求后，系统按下述步骤进行检查：
设 (1) 如果Requesti[j]≤Need[i,j]，便转向步骤(2)；否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。
(2) 如果Requesti[j]≤Available[j]，便转向步骤(3)；否则，表示尚无足够资源，Pi须等待。
(3) 系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：
Available[j]:= Available[j]-Request i[j]；
Allocation[i,j]:= Allocation[i,j]+Request i[j]；
Need[i,j]:= Need[i,j]-Request i[j]；
(4) 系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。
安全性算法过程:
(1) 设置两个向量：
① 工作向量Work，它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work=Available。
② Finish，它表示系统是否有足够的资源分配给进程，使之运行完成。开始时先做Finish[i]=false；当有足够资源分配给进程时，再令Finish[i]=true。
(2) 从进程集合中找到一个能满足下述条件的进程：
① Finish[i]=false；
② Need[i,j]≤Work[j]；若找到，执行步骤(3)，否则，执行步骤(4)。
(3) 当进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Work[j]= Work[j]+Allocation[i,j]；
Finish[i]=true；
go to step 2；
(4) 如果所有进程的Finish[i]=true都满足，则表示系统处于安全状态；否则，系统处于不安全状态。
检查死锁: 资源分配图简化法
1.为每个进程,资源标识
2.画出资源分配和请求图
3.开始化简资源分配图,如果能化简完所有箭头,则表示无死锁
解除死锁: 剥夺资源/销毁进程
1.剥夺其他线程资源,给死锁进程用
2.可以直接撤消死锁进程或撤消代价最小的进程,直至有足够的资源可用,死锁状态消除为止
银行家算法模拟实现:
#include<stdio.h>
#include <iostream>
#include<iomanip>
using namespace std;
#define MAXPROCESS 1000 /*最大进程数*/
#define MAXRESOURCE 1000 /*最大资源数*/
int AVAILABLE[MAXRESOURCE]; /*可用资源数组*/
int MAX[MAXPROCESS][MAXRESOURCE]; /*最大需求矩阵*/
int ALLOCATION[MAXPROCESS][MAXRESOURCE]; /*分配矩阵*/
int NEED[MAXPROCESS][MAXRESOURCE]; /*需求矩阵*/
int REQUEST[MAXPROCESS][MAXRESOURCE]; /*进程需要资源数*/
bool FINISH[MAXPROCESS]; /*系统是否有足够的资源分配*/
int p[MAXPROCESS]; /*记录序列*/
int m, n; /*m个进程,n个资源*/
int bank_flag = 0;/*标志是否有初始化资源*/
void Init();
bool Safe();
void Bank();
void Menu();
void Check();
void Show();
//主函数
int main()
{
Menu();
}
//主界面
void Menu()
{
while (1){
printf("=========================
");
printf("* 银行家算法 *
");
printf("* 1.设置资源初值 *
");
printf("* 2.安全性检测 *
");
printf("* 3.申请资源 *
");
printf("* 4.显示资源 *
");
printf("* 0.退出 *
");
printf("=========================
");
printf("请输入您的选项:");
int choice = 0;
cin >> choice;
switch (choice)
{
case 1:
Init();
break;
case 2:
Safe();
break;
case 3:
Bank();
break;
case 4:
Show();
break;
case 0:
return;
default:
cout << "输入非法,请重新输入!" << endl;
}
}
}
//展示资源
void Show()
{
if (bank_flag == 0)
{
cout << "请设置资源初值!" << endl;
cout << endl;
return;
}
//设置左对齐
cout << setiosflags(ios::left);
int w = 18;
cout << setw(w) << "Pid";
cout << setw(w) << "Max";
cout << setw(w) << "Allocation";
cout << setw(w) << "Need";
cout << setw(w) << "Available" << endl;
for (int i = 0; i < m; i++)
{
cout << setw(15) << i;
int wid = 18 / n;
for (int j = 0; j < n; j++)
{
cout << setw(wid) << MAX[i][j];
}
cout << " ";
for (int j = 0; j < n; j++)
{
cout << setw(wid) << ALLOCATION[i][j];
}
cout << " ";
for (int j = 0; j < n; j++)
{
cout << setw(wid) << NEED[i][j];
}
cout << " ";
if (i == 0)
{
for (int z = 0; z < n; z++){
cout << setw(wid) << AVAILABLE[z];
}
}
cout << endl;
}
cout << endl;
}
//回退步骤
bool Check(int flag)
{
return flag == -1? true : false;
}
//初始化
void Init()
{
cout << "如需回到主界面,输入-1" << endl;
int i, j;
cout << "请输入进程的数目:";
cin >> m;
if (Check(m))
return;
cout << "请输入资源的种类:";
cin >> n;
if (Check(n))
return;
cout << "请输入每个进程最多所需的各资源数,按照" << m << "x" << n << "矩阵输入" << endl;
for (i = 0; i < m; i++){
for (j = 0; j < n; j++){
cin >> MAX[i][j];
if (Check(MAX[i][j]))
return;
}
}
cout << "请输入每个进程已分配的各资源数,也按照" << m << "x" << n << "矩阵输入" << endl;
for (i = 0; i<m; i++)
{
for (j = 0; j<n; j++)
{
cin >> ALLOCATION[i][j];
NEED[i][j] = MAX[i][j] - ALLOCATION[i][j];
if (Check(ALLOCATION[i][j]))
return;
if (NEED[i][j]<0)
{
cout << "您输入的第" << i + 1 << "个进程所拥有的第" << j + 1 << "个资源数错误,请重新输入:" << endl;
j--;
continue;
}
}
}
cout << "请输入各个资源现有的数目:" << endl;
for (i = 0; i<n; i++)
{
cin >> AVAILABLE[i];
if (Check(AVAILABLE[i]))
return;
}
bank_flag = 1; //资源初始化成功标志
cout << endl;
}
//银行家算法
void Bank()
{
if (bank_flag == 0)
{
cout << "请设置资源初值!" << endl;
cout << endl;
return;
}
int i, cusneed;
int flag = 0;//银行家算法4步骤成功标志
//请求资源初始化
cout << "请输入要申请资源的进程号(下标从0开始):";
cin >> cusneed;
cout << "请输入进程所请求的各资源的数量:";
for (i = 0; i<n; i++)
{
cin >> REQUEST[cusneed][i];
}
//1.request[i][j]<=need[i][j]
//2.request[i][j]<=aval[i][j]
for (i = 0; i<n; i++)
{
if (REQUEST[cusneed][i]>NEED[cusneed][i])
{
cout << "请求数超过进程的需求量!" << endl;
flag = 1;
break;
}
if (REQUEST[cusneed][i]>AVAILABLE[i])
{
cout << "请求数超过系统有的资源数!" << endl;
flag = 1;
break;
}
}
if (flag == 1)
return;
//3.试图分配
//现有资源-req;i分配资源+req;i需求-req;
for (i = 0; i<n; i++)
{
AVAILABLE[i] -= REQUEST[cusneed][i];
ALLOCATION[cusneed][i] += REQUEST[cusneed][i];
NEED[cusneed][i] -= REQUEST[cusneed][i];
}
//4.安全性算法
if (Safe())
{
cout << "同意分配请求!" << endl;
}
else
{
//请求拒绝,还原资源
cout << "请求被拒绝!" << endl;
for (i = 0; i<n; i++)
{
AVAILABLE[i] += REQUEST[cusneed][i];
ALLOCATION[cusneed][i] -= REQUEST[cusneed][i];
NEED[cusneed][i] += REQUEST[cusneed][i];
}
}
//将完成标志重置为false
for (i = 0; i<m; i++)
{
FINISH[i] = false;
}
cout << endl;
}
//安全性算法
bool Safe()
{
if (bank_flag == 0)
{
cout << "请设置资源初值!" << endl;
cout << endl;
return false;
}
int i, j, k, l = 0;
int Work[MAXRESOURCE]; //工作数组
for (i = 0; i<n; i++) //初始化work
Work[i] = AVAILABLE[i];
for (i = 0; i<m; i++)
{
FINISH[i] = false;
}
for (i = 0; i<m; i++)
{
//进程资源已回收,找下一个
if (FINISH[i] == true)
{
continue;
}
//进程资源未会回收
else
{
//work[j]<need[i][j],不满足
for (j = 0; j<n; j++)
{
if (NEED[i][j]>Work[j])
{
break;
}
}
//work[j]>need[i][j],回收此进程资源
if (j == n)
{
FINISH[i] = true;
for (k = 0; k<n; k++)
{
Work[k] += ALLOCATION[i][k];
}
//回收的进程放入记录序列
p[l++] = i;
//重头继续找
i = -1;
}
else
{
continue;
}
}
//如果进程全部完成,则返回安全对列
if (l == m)
{
cout << "系统是安全的" << endl;
cout << "安全序列:" ;
for (i = 0; i<l; i++)
{
cout << p[i];
if (i != l - 1)
{
cout << "-->";
}
}
cout << "" << endl;
cout << endl;
return true;
}
}//end of for
//进程有未完成的,不安全
cout << "系统是不安全的" << endl;
cout << endl;
return false;
}