进程的并发和死锁——银行家算法

最新推荐文章于 2023-12-10 11:30:00 发布

QiaoXz_CN

最新推荐文章于 2023-12-10 11:30:00 发布

阅读量922

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/XUST_Kevin/article/details/83448793

操作系统专栏收录该内容

1 篇文章

订阅专栏

本文深入解析银行家算法，探讨如何避免系统死锁，通过资源分配和需求矩阵动态管理，确保进程安全运行。介绍算法实现步骤，包括资源请求验证、最大需求检查及安全状态评估。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

源代码下载：https://download.youkuaiyun.com/download/xust_kevin/10748248

进程的并发和死锁之银行家算法，Dijkstra把系统比作一个银行家，它占有有限资源。通过银行家算法来给资源请求的进程分配资源，以避免资源占用发生死锁。

考虑一个具有n个进程和m种不同类型资源的系统，每一个进程对系统发出资源请求，系统根据当前的资源分配情况和可利用资源量来动态分配资源。

变量说明：

Allocate：资源分配矩阵

表示系统当前已经分配给各个进程的资源数量

Available：可利用资源矩阵

表示系统当前可以用来分配的剩余资源

Claim：最大需求矩阵

表示每一个进程对每种资源所需要的最大数量

Resuorce：系统资源矩阵

表示系统总共拥有的每种资源数量

Need：资源需求矩阵

表示每个进程当前所需要得到的每种资源数量

基本思想：

在每一个进程请求系统分配资源时，根据银行家算法的原理判断请求的资源是否可合理以及分配资源后的进程是否安全来进行判断，如果满足以上两个条件则分配当前进程请求的资源数量，否则拒绝分配资源。

关键点：

判断请求资源是否大于可利用资源
判断请求资源是否大于最大需求资源
判断分配资源后进程是否安全
系统状态的回滚（初态和末态的选择，回滚即为拒绝分配资源）

实现步骤：

1.判断请求资源是否大于可利用资源

通过函数传参的方式将当前进程号和请求的资源传入函数中

用系统资源矩阵减去资源分配矩阵（需要做统一维度处理，即每一列相加得到每一种资源已分配的数量）得到可利用资源矩阵，判断请求资源是否大于对应的可以利用资源，否则拒绝资源请求

代码如下：

int temp ;
for (i = 0; i < M; i++)
{
    temp = 0;
    for (j = 0; j < N; j++)
    temp+= Allocate[j][i];
    Avaliable[i] = Resource[i] - temp;
}
			

//拷贝可利用资源
for (i = 0; i < M; i++)
    Avaliable_copy[i] = Avaliable[i];

//判断请求资源是否超过可利用的资源
bool flag_request = true;
for (int count = 0; count < M; count++)
{
	if (Avaliable[count] - Request[count] >= 0)
		Avaliable_copy[count] = Avaliable[count] - Request[count];
        else
	    {
		flag_request = false;
		break;
	    }
}

2.判断请求资源是否大于最大需求资源

在当前可利用资源可以进行资源分配的情况下，对请求资源的进程分配相应的资源数量，对进行分配后的资源分配矩阵进行检查，判断资源分配矩阵是否存在分配资源大于最大需求资源的情况，如果分配资源矩阵中的当前进程的分配资源都没有大于其所需要的最大需求资源则分配资源，否则拒绝资源请求

代码如下：

for (i = 0; i < N; i++)
    for (j = 0; j < M; j++)
    {
        Allocate_copy[i][j] = Allocate[i][j];//拷贝分配矩阵
        Need_copy[i][j] = Need[i][j];//拷贝需求矩阵
    }
				
for (i = 0; i < M; i++)
    Allocate_copy[pro_number - 1][i] += Request[i];//分配请求资源

for (i = 0; i < M; i++)//判断请求资源是否大于最大所需资源
    if (Allocate_copy[pro_number - 1][i] > Claim[pro_number - 1][i])
	{
	    flag_need = false;
	    break;
	}

3.判断分配资源后进程是否安全

当前两个条件都满足的情况下，判断分配资源给当前进程后，系统剩下的可利用资源是否可以满足分配给任意一个未达到最大资源需求的进程（剩余资源能够分配个某个进程，使得这个进程达到最大资源需求量，以运行完这个进程，释放出更多的资源）

代码如下：

for (i = 0; i < N; i++)
    for (j = 0; j < M; j++)
        Need_copy[i][j] = Claim[i][j] - Allocate_copy[i][j];//重新分配资源后的需求矩阵

//判断分配资源后，可利用资源能否满足结束任意一个进程
bool flag_process[N] = { true,true,true,true };
for (i = 0; i < N; i++)
    for (j = 0; j < M; j++)
        if (Need_copy[i][j] > Avaliable_copy[j])
            flag_process[i] = false;

4.系统状态的回滚

因为在判断不满足分配资源条件后应该拒绝资源请求，所以应该将所有相关的资源恢复到之前的状态。我在程序中使用copy代替分配的矩阵，如果满足分配条件就将copy矩阵的值拷贝给原矩阵，否者不作复制操作（保持原来的状态不变）

完整代码：

下面提供银行加算法的完整算法，因为时间仓促，写的比较乱，没有将没个方法单独分开。请读者根据步骤自行设计。

详细代码:

bool Banker(int(&Allocate)[N][M], int(&Request)[M], int pro_number)
{
    int Need[N][M] = { 0 };
    int Need_copy[N][M] = { 0 };
    int Avaliable[M] = { 0 };
    int Avaliable_copy[M] = { 0 }；
    int Allocate_copy[N][M] = { 0 };
    //求需求（Need）矩阵
    for (i = 0; i < N; i++)
        for ( j = 0; j < M; j++)
	    Need[i][j] = Claim[i][j] - Allocate[i][j];

    //求可利用资源(Avaliable)矩阵
    int temp ;
    for (i = 0; i < M; i++)
	{
	    temp = 0;
	    for (j = 0; j < N; j++)
	    temp+= Allocate[j][i];
	    Avaliable[i] = Resource[i] - temp;
	}
			

    //拷贝可利用资源
    for (i = 0; i < M; i++)
	Avaliable_copy[i] = Avaliable[i];

    //判断请求资源是否超过可利用的资源
    bool flag_request = true;
    for (int count = 0; count < M; count++)
	{
	    if (Avaliable[count] - Request[count] >= 0)
	        Avaliable_copy[count] = Avaliable[count] - Request[count];
	    else
	        {
		    flag_request = false;
		    break;
		}
	}

    bool flag_assign = false;
    bool flag_need = true;
    //当可利用资源足够分配时判断是否安全
    if (flag_request == true)
	{
	    for (i = 0; i < N; i++)
		for (j = 0; j < M; j++)
                    {
			Allocate_copy[i][j] = Allocate[i][j];//拷贝分配矩阵
			Need_copy[i][j] = Need[i][j];//拷贝需求矩阵
		    }
				
		for (i = 0; i < M; i++)
		    Allocate_copy[pro_number - 1][i] += Request[i];//分配请求资源

		for (i = 0; i < M; i++)//判断请求资源是否大于最大所需资源
		    if (Allocate_copy[pro_number - 1][i] > Claim[pro_number - 1][i])
			{
			    flag_need = false;
			    break;
			}
					
		if (flag_need == true)
		    {
		        for (i = 0; i < N; i++)
			    for (j = 0; j < M; j++)
	                        Need_copy[i][j] = Claim[i][j] - Allocate_copy[i][j];//重新分配资源后的需求矩阵
			//判断分配资源后，可利用资源能否满足结束任意一个进程
			bool flag_process[N] = { true,true,true,true };
			for (i = 0; i < N; i++)
				for (j = 0; j < M; j++)
				        if (Need_copy[i][j] > Avaliable_copy[j])
					    flag_process[i] = false；						
					
			//当分配资源后是进程安全时，执行分配
			int count = 0;
			for (i = 0; i < N; i++)
			    if (flag_process[i] == true)
				count++;

			cout <<"安全进程个数:"<< count << endl<<endl;
			if (count>0)
			    {

			        flag_assign = true;
				for (i = 0; i < N; i++)
				    for (j = 0; j < M; j++)
					{
					    Allocate[i][j] = Allocate_copy[i][j];
					    Need[i][j] = Need_copy[i][j];
					}
				for (i = 0; i < M; i++)
				    Avaliable[i] = Avaliable_copy[i];
				}

				if (flag_assign == true)
				{
					//显示分配信息
					cout << "Allocate=" << endl;//执行分配后的分配矩阵
					for (i = 0; i < N; i++)
					{
						for (j = 0; j < M; j++)
							cout << Allocate[i][j] << "  ";
						cout << endl;
					}
						
					cout << endl;

					cout << "Need=" << endl;//执行分配后的需求矩阵
					for (i = 0; i < N; i++)
					{
						for (j = 0; j < M; j++)
							cout << Need[i][j] << "  ";
						cout << endl;
					}
						
					cout << endl;

					cout << "Avaliable=" << endl;//执行分配后的可利用矩阵
					for (i = 0; i < M; i++)
						cout << Avaliable[i]<<" ";
					cout << endl;
					release(pro_number);
					return true;
				}
				else
				{
					cout << "执行分配不安全" << endl;
					return false;
				}


			}
			else
			{
				cout << "请求资源超过最大所需资源"<<endl;
					return false;
			}
				

		}
		else
		{
			cout << "请求资源大于可利用资源"<<endl;
			return false;
		}

		
	}

源代码下载：https://download.youkuaiyun.com/download/xust_kevin/10748248