操作系统之银行家算法

已于 2022-03-17 21:37:01 修改
阅读量245 收藏
点赞数
文章标签： 算法 矩阵 c++
于 2022-03-17 21:31:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/likesile/article/details/123561293
版权 
#include<iostream>
#include<assert.h>
#include<graphics.h>
#include<time.h>
#include<conio.h>
using namespace std;
const int MAXPROCESS=100;
const int MAXRESOURCE=100; 
 
int Available[MAXRESOURCE];         //可用资源向量  
int Max[MAXPROCESS][MAXRESOURCE];   //最大需求矩阵  
int Allocation[MAXPROCESS][MAXRESOURCE];  //分配矩阵  
int Need[MAXPROCESS][MAXRESOURCE];        //需求矩阵  
 
int Request[MAXRESOURCE];      //请求向量  
 
int Work[MAXRESOURCE];         //工作向量  
bool Finish[MAXPROCESS]; 
int SafeSeries[MAXPROCESS];    //安全序列  
 
int n;   //进程数  
int m;   //资源数  
 
void Init()   //初始化模块
{ 
	rectangle(100, 50, 680, 100);  //输入进程数
	outtextxy(110, 60, "请输入进程总数:");
	char a[20],num[20];
	int i,g,j;
	int c;
	for(i=0;i<20;i++)
	{
		if((c=getchar())!='\n') 
			a[i]=c; 
		else 
		{
			a[i]=0;
			break;
		}
	}
	n=atoi(a);
	sprintf(num,"%d",n);
	outtextxy(400,60,num);

	rectangle(100, 100, 680, 150);  //输入资源种类数
	outtextxy(110, 110, "请输入资源种类数:");
	for(i=0;i<20;i++)
	{
		if((c=getchar())!='\n') 
			a[i]=c; 
		else 
		{
			a[i]=0;
			break;
		}
	}
	m=atoi(a);
	sprintf(num,"%d",m);
	outtextxy(400,110,num);
  
	rectangle(100, 150, 680, 200);   //输入资源数目
	outtextxy(110, 160, "请输入可利用资源数目:");
	int f=420;
	for( j = 0; j < m; ++j )  
	{  
		for(i=0;i<20;i++)
		{
			if((c=getchar())!='\n') 
				a[i]=c; 
			else 
			{
				a[i]=0;
				break;
			}
		}
		Available[j]=atoi(a);
		sprintf(num,"%d",Available[j]);
		outtextxy(f=f+30,160,num);
	}  

	rectangle(100, 200, 680,260+n*30);  //最大矩阵输入
	outtextxy(110, 210, "最大需求矩阵输入:");
	int b=250,w=450,d=650,q=110;
	for( i = 0; i < n; ++i )  
	{  
		for( j = 0; j < m; ++j )  
		{ 
			for(int k=0;k<20;k++)
			{
				if((c=getchar())!='\n') 
					a[k]=c; 
				else 
				{
					a[k]=0;
					break;
				}
			}
			Max[i][j]=atoi(a);
			sprintf(num,"%d",Max[i][j]);
			outtextxy(q=q+30,b,num); 
		}
		b=b+30;
		q=110;
	} 

	rectangle(100, 400, 680,460+n*30);  //最大矩阵输入
	outtextxy(110, 410, "分配矩阵输入:");
	q=110;
	for( i= 0; i < n; ++i )  
	{  
		for( j = 0; j < m; ++j )  
		{  
			for(int k=0;k<20;k++)
			{
				if((c=getchar())!='\n') 
					a[k]=c; 
				else 
				{
					a[k]=0;
					break;
				}
			}
			Allocation[i][j]=atoi(a);
			sprintf(num,"%d",Allocation[i][j]);
			outtextxy(q=q+30,w,num); 
		}
		w=w+30; 
		q=110;
	}  

	rectangle(100, 600, 680,660+n*30);  //最大矩阵输入
	outtextxy(110,610, "需求矩阵输入:");
	q=110;
	for( i = 0; i < n; ++i )  
	{  
		for( j = 0; j < m; ++j )  
		{  
			for(int k=0;k<20;k++)
			{
				if((c=getchar())!='\n') 
					a[k]=c; 
				else 
				{
					a[k]=0;
					break;
				}
			}
			Need[i][j]=atoi(a);
			sprintf(num,"%d",Need[i][j]);
			outtextxy(q=q+30,d,num); 
		}
		d=d+30; 
		q=110;
	}  
}  

 
bool IsSafe()   //判断安全性算法
{  
	int i=0;
	for (i=0;i<n;++i)
	{
		if(Finish[i] == true)
			continue;
		else
			break;
	}
	if(i == n)
		return true;    //安全
	else
		return false;   //不安全
}   
 
bool Select(int &tmp,int tmpNeed[][MAXRESOURCE])  //选则模块
{  
	//选择一个Finish[i]=false,Need[i]<=Work[i] 
	int j=0; 
	for (int i=0;i<n;++i)
	{
		if(Finish[i])
			continue;
		for (j=0;j<m;++j)
		{
			if(tmpNeed[i][j] > Work[j])
				break;
		}
		if(j == m)
		{
			tmp=i;
			return true;
		}
	}
	return false;
}  
 
bool Safe(int *tmpAvail,int tmpAlloc[][MAXRESOURCE],int tmpNeed[][MAXRESOURCE])  //输出安全序列模块
{  
	for(int i = 0; i < n; ++i)  
	{  
		Finish[i] = false;  
	}  
	for (int j = 0; j < m; ++j)  
	{  
		Work[j] = tmpAvail[j];  
	}  
	int tmp=0;  
	int index = 0;  
	while(Select(tmp,tmpNeed))  
	{  
		Finish[tmp] = true;  
		for (int k = 0; k < m; ++k)  
		{  
			Work[k] += tmpAlloc[tmp][k];  
		}  
		SafeSeries[index++] = tmp;
	}  
	if(IsSafe())  
		return true;    //安全
	else
		return false;   //不安全
}   
 
void Display()  //显示模块
{
	int i=0;
	int j=0,a=110,b=250,c=450,d=650;
	char num[20];
	rectangle(100, 100, 500, 200);
	outtextxy(110,110,"当前可利用的资源数目:");
	for(i = 0; i < m; ++i)  
	{  
		sprintf(num,"%d",Available[i]);
		outtextxy(a=a+20,150,num);
	}  
	rectangle(100, 200, 500, 260+n*30);
	outtextxy(110,210,"最大需求矩阵:");
	a=110;
	for(i = 0; i < n; ++i )  
	{  
		for( j = 0; j < m; ++j)  
		{  
			sprintf(num,"%d",Max[i][j]);
		    outtextxy(a=a+20,b,num);
		}
		b=b+30;
		a=110;
	} 
	rectangle(100, 400, 500, 460+n*30);
	outtextxy(110,410,"分配矩阵:");
	a=110;
	for( i = 0; i < n; ++i )  
	{  
		for( j = 0; j < m; ++j )  
		{  
			sprintf(num,"%d",Allocation[i][j]);
		    outtextxy(a=a+20,c,num);
		}  
		c=c+30;
		a=110;
	}
	rectangle(100, 600, 500, 660+n*30);
	outtextxy(110,610,"需求矩阵:");
	a=110;
	for( i = 0; i < n; ++i )  
	{  
		for( j = 0; j < m; ++j )  
		{ 
			sprintf(num,"%d",Need[i][j]);
		    outtextxy(a=a+20,d,num);;
		}  
		d=d+30;
		a=110;
	} 
}
 
void BankA()  //银行家算法
{
	int i=0;
	int index=0;
	rectangle(100, 50, 680, 100);  //输入进程数
	outtextxy(110, 60, "请输入请求资源的进程下标:");
	char a[20],num[20];
	int j;
	char c;
	for(i=0;i<20;i++)
	{
		if((c=getchar())!='\n') 
			a[i]=c; 
		else 
		{
			a[i]=0;
			break;
		}
	}
	index=atoi(a);
	sprintf(num,"%d",index);
	outtextxy(650,60,num);

	assert(index < n && index >= 0);
	rectangle(100, 100, 680, 150);  //输入进程数
	outtextxy(110, 110, "请输入当前的请求资源:");
	int b=500;
	for (j=0;j<m;++j)
	{
		for(i=0;i<20;i++)
		{
			if((c=getchar())!='\n') 
				a[i]=c; 
			else 
			{
				a[i]=0;
				break;
			}
		}
		Request[j]=atoi(a);
		sprintf(num,"%d",Request[j]);
		outtextxy(b=b+30,110,num);
	}

	for (i=0;i<m;++i)
	{
		if(Request[i] <= Need[index][i])
		{
			continue;
		}
		else
		{
			rectangle(300, 550, 650, 600);
			outtextxy(310, 560, "第一次试分配失败");
			break;
		}
	}
	if(i < 3)   //如果第一次试分配失败则不执行后面的语句
	{
		return ;
	}
	for(i=0;i<m;++i)
	{
		if(Request[i] <= Available[i])
		{
			continue;
		}
		else
		{
			rectangle(300, 550, 650, 600);
			outtextxy(310, 560, "第二次试分配失败");
			break;
		}
	}
	if(i <3)     //如果第二次试分配失败则不同执行后面的语句
	{
		return ;
	}
	//开始试分配
	int tmpAvail[MAXRESOURCE]={0};
	int tmpAlloc[MAXPROCESS][MAXRESOURCE]={0};
	int tmpNeed[MAXPROCESS][MAXRESOURCE]={0};
	memmove(tmpAvail,Available,sizeof(int)*MAXRESOURCE);
	memmove(tmpAlloc,Allocation,sizeof(int)*MAXPROCESS*MAXRESOURCE);
	memmove(tmpNeed,Need,sizeof(int)*MAXPROCESS*MAXRESOURCE);
	for (int i=0;i<m;++i)
	{
		tmpAvail[i] -= Request[i];
		tmpAlloc[index][i] += Request[i];
		tmpNeed[index][i] -= Request[i];
	}
	bool ret=Safe(tmpAvail,tmpAlloc,tmpNeed);
	if(ret == true)
	{
		memmove(Available,tmpAvail,sizeof(int)*MAXRESOURCE);
		memmove(Allocation,tmpAlloc,sizeof(int)*MAXPROCESS*MAXRESOURCE);
		memmove(Need,tmpNeed,sizeof(int)*MAXPROCESS*MAXRESOURCE);
		cout<<"进程p"<<index<<"请求资源允许"<<endl;
	}
	else
	{
		for(int i = 0; i < n; ++i)  
		{  
			Finish[i] = false;  
		}
		rectangle(300, 550, 650, 600);
		outtextxy(310, 560, "第三次试分配失败");
	}
}
 
void Menu() //界面函数
{
	initgraph(880, 880);
	setbkcolor(LIGHTGRAY);
	cleardevice();
	setlinecolor(BLACK);
	rectangle(80 , 50 , 800, 200);
	rectangle(300, 300, 580, 350);
	rectangle(300, 400, 580, 450);
	rectangle(300, 500, 580, 550);
	rectangle(300, 600, 580, 650);
	rectangle(300, 700, 580, 750);
	settextcolor(BLACK);
	settextstyle(100,0,0);
	outtextxy(200,70,"银行家算法");
	settextstyle(30, 0, 0);
	outtextxy(320, 310, "测试安全性代码");
	outtextxy(320, 410, "测试银行家算法");
	outtextxy(320, 510, "初始化");
	outtextxy(320, 610, "打印矩阵");
	outtextxy(320, 710, "退出");
}

int main()  //主函数
{
	int index=0;
	int flag=1;
	MOUSEMSG m;
	Menu();
	while (flag)   //功能函数调用
	{
		m = GetMouseMsg();
		if (m.mkLButton&&m.x > 300 && m.x < 580 && m.y>300 && m.y < 350)
		{
			cleardevice();
			Safe(Available,Allocation,Need);
			if(IsSafe())  
			{  
				rectangle(100, 200, 500, 300);
				outtextxy(110,210,"安全序列为:"); 
				int a=110;
				char num[20];
				for (int i = 0; i < n ; ++i)  
				{ 
					sprintf(num,"%d",SafeSeries[i]);
					outtextxy(a=a+30,250,"P");
					outtextxy(a=a+20,250,num);
				}  
				for(int i = 0; i < n; ++i)  
				{  
					Finish[i] = false;  
				}
			}   
			else  
			{ 
				rectangle(100, 400, 500, 500);
				outtextxy(110,410,"该时刻是不安全的!"); 
			} 
		    rectangle(700, 50, 870, 100);
			outtextxy(710, 60, "返回主界面");
			int t=1;
			MOUSEMSG m1;
			while(t)
			{
				m1= GetMouseMsg();
				if(m1.mkLButton&&m1.x > 700 &&m1.x < 870 &&m1.y>50 && m1.y < 100)
				{
					Menu();
					t=0;
				}
			}
		}
		else if (m.mkLButton&&m.x > 300 && m.x < 580 && m.y>400 && m.y < 450)
		{
			cleardevice();
			BankA();
			char c=getchar();
			while(c)
			{
			if(IsSafe())  
			{   
				rectangle(100, 200, 500, 300);
				outtextxy(110,210,"安全序列为:"); 
				int a=110;
				char num[20];
				for (int i = 0; i < n ; ++i)  
				{ 
					sprintf(num,"%d",SafeSeries[i]);
					outtextxy(a=a+30,250,"P");
					outtextxy(a=a+20,250,num);
				}  
				for(int i = 0; i < n; ++i)  
				{  
					Finish[i] = false;  
				} 
			}
			else
			{
				rectangle(100, 400, 500, 500);
				outtextxy(110,410,"该时刻是不安全的!"); 
			}
			
			c=0;
			}
			rectangle(700, 50, 870, 100);
			outtextxy(710, 60, "返回主界面");
			int t=1;
			MOUSEMSG m2;
			while(t)
			{
				m2= GetMouseMsg();
				if(m2.mkLButton&&m2.x > 700 &&m2.x < 870 &&m2.y>50 && m2.y < 100)
				{
					Menu();
					t=0;
				}
			}
		}
		else if (m.mkLButton&&m.x > 300 && m.x < 580 && m.y>500 && m.y < 550)
		{
			cleardevice();
			Init();
			rectangle(700, 50, 870, 100);
			outtextxy(710, 60, "返回主界面");
			int t=1;
			MOUSEMSG m3;
			while(t)
			{
				m3= GetMouseMsg();
				if(m3.mkLButton&&m3.x > 700 &&m3.x < 870 &&m3.y>50 && m3.y < 100)
				{
					Menu();
					t=0;
				}
			}
		}
		else if (m.mkLButton&&m.x > 300 && m.x < 580 && m.y>600 && m.y < 650)
		{
			cleardevice();
			Display();
			rectangle(700, 50, 870, 100);
			outtextxy(710, 60, "返回主界面");
			int t=1;
			MOUSEMSG m4;
			while(t)
			{
				m4= GetMouseMsg();
				if(m4.mkLButton&&m4.x > 700 &&m4.x < 870 &&m4.y>50 && m4.y < 100)
				{
					Menu();
					t=0;
				}
			}
		}
		else if (m.mkLButton&&m.x > 300 && m.x < 580 && m.y>700 && m.y < 750)
			flag=0;
	}
}

使用easyx画了界面！

likesile
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
操作系统第三章：银行家算法
你说的白是什么白_
10-22 2万+
文章目录银行家算法1. 银行家算法中的数据结构2. 银行家算法的处理步骤3. 安全性算法4.举例5.银行家算法总结 银行家算法 银行家算法是最有代表性的避免死锁的算法。 由于该算法能用于银行系统现金贷款的发放而得名的。 1. 银行家算法中的数据结构 设系统中有m类资源，n个进程 （1）可利用资源向量Available。含有m个元素的一维数组，每个元素代表一类可利用的资源数目。 如果Available[j]=k,表示系统中现有Rj类资源k个。 （2）最大需求矩阵Max， 是一个n*m的矩阵，定义了系统中n个
操作系统银行家算法模拟实现（C语言版）
热门推荐
闭关修炼——暂退
05-23 8万+
目录 一、实验目的 二、实验内容 三、实验要点说明 银行家算法实例 程序结构 四、实验代码 五、实验运行结果 一、实验目的 通过编写一个模拟动态资源分配的银行家算法程序，进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念，并掌握避免死锁的具体实施方法。 二、实验内容 （1）模拟一个银行家算法： 设置数据结构 设计安全性算法 （2） 初始化时让系统拥有一定的资源 （3） 用键盘输入的方式申请资源 （4）如果预分配后，系统处于安全...
操作系统：银行家算法（C++版）
最新发布
qq528178306的博客
05-01 304
银行家算法（Banker's Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。
一文搞懂操作系统中银行家算法
m0_63006478的博客
05-25 4676
在安全序列中，每个进程按照其所需资源的顺序依次执行，并在执行完毕后释放所占用的资源，这样其他进程才能获取到所需的资源。总结来说，不安全状态指的是系统无法找到一种执行顺序，使得每个进程都能在其所需资源得到满足时执行，并在执行完毕后释放资源，可能导致死锁的发生。总结来说，安全序列是指满足系统安全性要求的进程执行顺序，其中每个进程都能在其所需资源得到满足时执行，并在执行完毕后释放资源，而不会发生死锁。安全序列的存在意味着系统中的资源分配是合理的，并且可以满足所有进程的需求，从而确保系统的可靠性和稳定性。
银行家算法
有为肥宅的博客
07-13 1824
银行家算法（操作系统课设作业）
银行家算法及其c++代码实现
weixin_39660224的博客
08-05 2562
最近小编在学习自考操作系统的过程中，了解到了一种可以避免进程死锁的算法-----银行家算法 如果您已经知道什么是银行家算法，只想看代码，直接到 源码部分 什么是银行家算法 银行家算法是操作系统中避免死锁的一种算法 什么是死锁 和我们线程死锁类似，不同线程持有对方的锁，多个线程又不能释放锁，即产生死锁 类似上图，P1 申请 输出设备，但是输出设备被P2占有，P2又申请输入设备 输入设备又被P1占有形成回路 如何避免呢？ 和简单只要在资源分配前检测当前系统是否处于安全状态，是否能被分配，分配之后系统是否还是安
操作系统之银行家算法：从原理到实现的死锁避免教程
01-08
操作系统之银行家算法：从原理到实现的死锁避免教程 操作系统之银行家算法：从原理到实现的死锁避免教程 操作系统之银行家算法：从原理到实现的死锁避免教程 操作系统之银行家算法：从原理到实现的死锁避免教程 ...
操作系统银行家算法避免死锁
06-17
银行家算法避免死锁 VM软件 Linux系统 C语言 成功编译 成功运行 内附完整课设报告，代码，运行cpp 附有哲学家进餐简略一题 原课设要求：死锁避免 （1）请设计一个程序演示死锁避免算法（银行家算法）。 （2）要求该...
计算机操作系统之银行家算法
12-23
银行家算法（Banker's Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行...
操作系统之银行家算法.pdf
06-21
操作系统实验教程，操作系统有很多，我们需要去学习和掌握，我们要通过做虚拟的操作系统实验，了解操作系统的工作机制。
操作系统-银行家算法
06-30
操作系统至银行家算法，可以直接运行，带注释，交作业非常方便
操作系统银行家算法
06-05
操作系统银行家算法，绝对可运行，包含代码
操作系统之银行家算法源代码
01-20
银行家算法是避免死锁的一种重要方法，本程序用java编程语言对其进行了实现。 当用户申请一组资源时，系统必须做出判断，如果把这些资源分出去，系统是否还处于安全状态。 若是，就可以分出这些资源；否则，该申请暂不予满足。 1．数据结构 假设有M个进程N类资源，则有如下数据结构： MAX[M*N] M个进程对N类资源的最大需求量 AVAILABLE[N] 系统可用资源数 ALLOCATION[M*N] M个进程已经得到N类资源的资源量 NEED[M*N] M个进程还需要N类资源的资源量 2．银行家算法 设进程I提出请求Request[N]，则银行家算法按如下规则进行判断。 (1)如果Request[N]<=NEED[I，N]，则转(2)；否则，出错。 (2)如果Request[N]<=AVAILABLE，则转(3)；否则，出错。 (3)系统试探分配资源，修改相关数据： AVAILABLE=AVAILABLE-REQUEST ALLOCATION=ALLOCATION+REQUEST NEED=NEED-REQUEST (4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。 3．安全性检查 (1)设置两个工作向量WORK=AVAILABLE；FINISH[M]=FALSE (2)从进程集合中找到一个满足下述条件的进程， FINISH[i]=FALSE NEED<=WORK 如找到，执行(3)；否则，执行(4) (3)设进程获得资源，可顺利执行，直至完成，从而释放资源。 WORK=WORK+ALLOCATION FINISH=TRUE GO TO 2 (4)如所有的进程Finish[M]=true，则表示安全；否则系统不安全。
（操作系统） C++ 银行家算法
imagination_123的博客
05-19 721
设计五个进程{P0，P1，P2，P3，P4}共享三类资源{A，B，C}的系统，{A，B，C}的资源数量分别为10，5，7。（2）若进程P1请求资源，发出请求向量Request1（1，0，2），编写程序用银行家算法判断系统能否将资源分配给它；3 0 2 （表示P2已经获得的3个资源的个数）2 1 1 （表示P3已经获得的3个资源的个数）0 0 2 （表示P4已经获得的3个资源的个数）0 1 0 （表示P0已经获得的3个资源的个数）2 0 0 （表示P1已经获得的3个资源的个数）
操作系统--银行家算法
weixin_44057997的博客
01-28 1644
一、 需求分析 （1）问题分析： 银行家算法是避免死锁的算法，它是在系统进行资源分配之前，计算此次分配后状态的安全性。若此次分配后的状态是安全状态，则将资源分配给进程，若不是安全状态则令进程等待。 （2）功能要求： 有录入界面，动态录入进程数、资源种类数、各类资源总数、T0时刻各进程的最大需求数、已分配数等信息； 有算法选择界面，能够进行安全性检测、对进程动态请求资源的银行家算法检查、退出等的功能选择，要求可以进行多进程多次的资源请求； 有输出界面，要求能够输出安全性检测的结果、如安全能够输出安全序列
Android多进程加载资源失败问题分析:android.content.res.Resources$NotFoundException: Resource ID #0x7f08XXXX
zhanghao_Hulk的专栏
09-08 1900
在Android开发中如果存在多进程共享资源用法时, 会出现资源到不到问题. 真实碰到的问题, 记录下来提供同学们参考 一, 崩溃信息 崩溃日志如下 --------- beginning of crash 08-17 18:54:00.622 17167 17167 E AndroidRuntime: FATAL EXCEPTION: main 08-17 18:54:00.622 17167 17167 E AndroidRuntime: Process: com.mobile.emm.trus
操作系统——银行家算法
一枚菜鸡
02-14 944
背景简介 核心思想 在银行中，客户申请贷款的数量是有限的，每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量，在满足所有贷款要求时，客户应及时归还。银行家在客户申请的贷款数量不超过自己拥有的最大值时，都应尽量满足客户的需要。 在这样的描述中，银行家就好比操作系统，资金就是资源，客户就相当于要申请资源的进程。系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。 安全序列 所谓安全序列，就是指如果系统按照这种序列分配资源，则每个进程都能顺利完成。只要
操作系统之银行家算法大题解题思路（含例题）
qq_41541801的博客
06-26 3万+
银行家算法大题解题思路
操作系统实验-银行家算法
m0_71334725的博客
02-13 1943
Work=Available，依次判断Need是否小于等于Work，如果小于等于，就分配资源，进程运行完成之后，收回分配给进程的所有资源。再次寻找满足Need小于等于Work的进程，重复上述步骤，直至所有进程的Finish=true，或者剩余的所有进程都不满足Need<=Work的条件。指系统能按照某种顺序如(称为序列为安全序列)，为每个进程分 配所需的资源，直至最大需求，使得每个进程都能顺利完成。由上图所示，所有进程的Finish=true，所以系统是安全的，测试序列就是安全序列。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

likesile

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值