死锁详解(预防,避免,检测,解除)

　　　　　死锁: 指多个进程/线程并发执行中,由于争抢资源而造成的阻塞现象。

　　　　　产生死锁的必要条件:　　　

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