C++ 银行家算法与时间片轮转调度算法结合

这篇具有很好参考价值的文章主要介绍了C++ 银行家算法与时间片轮转调度算法结合。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

声明:未经允许,请勿转载

一.实验目的

(1) 掌握 RR(时间片调度) 算法,了解 RR 进程调度

(2) 了解死锁概念,理解安全状态,并且理解银行家算法

(3) 利用 RR 进程调度与银行家算法结合,写出一个简单的项目

二.实验原理

2.1 时间片调度算法

      在分时系统中都采用时间片轮转算法进行进程调度。时间片是指一个较小的时间间隔,通常为 10- 100 毫秒。在简单的轮转算法中,系统将所有的就绪进程按先来先服务(即 FIFO)规则排成一个队列, 将 CPU 分配给队首进程,且规定每个进程最多允许运行一个时间片;若时间片使用完进程还没有结束, 则被加入就绪 FIFO 队列队尾,并把 CPU 交给下一个进程。时间片轮转算法只用于进程调度,它属于 抢占调度方式。

C++ 银行家算法与时间片轮转调度算法结合

算法实现: 

(1) 假设系统中有 5 个进程,每个进程有一个进程控制块(PCB)来标识。进程控制块内容包括:进 程名,链接指针,到达时间,估计运行时间,进程状态。进程名即进程标识。链接指针:按照进 程到达系统的时间将处于就绪状态的进程连接成一个就绪队列。指针指出下一个到达进程的进程 控制块地址。最后一个进程的链接指针为 NULL。

(2) 为每个进程任意确定一个到达时间和要求运行时间。

(3) 设置一个队首指针,用来指出最先进入系统的进程。各就绪进程通过链接指针连在一起构成一个 循环队列。

(4) 处理机调度时开始选择队首指针指向的进程投入运行。由于本实验是模拟试验,所以对被选中进 程并不实际启动运行,而只是执行:估计运行时间减 1。用这个操作来模拟进程的一次运行,而 且省去进程的现场保护和现场恢复工作。 2 电气与计算机工程学院实验报告

(5) 进程运行一次后,以后的调度则将当前指针依次下移一个位置,指向下一个进程。同时还应判断 该进程的剩余的运行时间是否为 0,若不为 0,则等待下一轮的运行;若该进程的剩余时间为 0, 则把它的状态改为完成态(C),并撤出就绪队列。

(6) 若就绪队列非空,则重复上述的(4)和(5),直到所有进程为完成态。

(7) 在所设计的程序中应有显示或打印语句,能显示或打印正运行进程的进程名、已运行时间、还剩 时间、就绪队列中的进程等。

C++ 银行家算法与时间片轮转调度算法结合

2.2 银行家算法

银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源, 但系统在进行资源分配之前,应先计算此次分配资源的安全性,若分配不会导致系统进入不安全状态, 则分配,否则等待。为实现银行家算法,系统必须设置若干数据结构。

银行家算法中的数据结构  

为了实现银行家算法,在系统中必须设置这样四个数据结构: 可利用资源向量 Available, 最大需 求矩阵 Max, 分配矩阵 Allocation, 需求矩阵 Need.

银行家算法详述:

设 Request;是进程 Pi 的请求向量,如果 Requesti[j] = K,表示进程 Pi 需要 K 个 Rj 类型的资 源。当 Pi 发出资源请求后,系统按下述步骤进行检査: 

(1) 如果 Requesti[j] Need[i,j] 便转向步骤

(2);否则认为出错,因为它所需要的资源数已超过它所 宣布的最大值 (2) 如果 Requesti[j] Available[j],便转向步骤

(3);否则,表示尚无足够资源,Pi 须等待。 (3) 系统试探着把资源分配给进程 Pi,并修改下面数据结构中的数值

Available[j] = Available[j] − Requesti[j]

Allocation[i, j] = Allocation[i, j] + Requesti[j]

Need[i, j] = Need[i, j] − Requesti[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 获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故应执行:

W ork[j] = W ork[j] + Allocation[i, j]

F inish[i] = true

go to step 2

(4) 如果所有进程的 Finish[i] =true 都满足,则表示系统处于安全状态;否则,系统处于不安全状态。

C++ 银行家算法与时间片轮转调度算法结合

三.实验过程

3.1 RR 算法与银行家算法结合的实现

1、假定系统有 3 类资源 A(10 个)、B(15 个)、C(12 个),系有 5 个进程并发执行,进程调度 采用时间片轮转调度算法。

2、每个进程由一个进程控制块(PCB)表示,进程控制块可以包含如下信息:进程名、需要的资 源总数、已分配的资源数、进程状态。

3、由程序自动生成进程(包括需要的数据,要注意数据的合理范围)。

4、进程在运行过程中会随机申请资源(随机生成请求的资源数),如果达到最大需求,表示该进程 可以完成;如果没有达到最大需求,则运行一个时间片后,调度其它进程运行。资源分配采用银行家算 法来避免死锁。

5、每个进程的状态可以是就绪 W(Wait)、运行 R(Run)、阻塞 B(Block)或完成 F(Finish) 状态之一。 5 电气与计算机工程学院实验报告

6、每进行一次调度,程序都要输出一次运行结果:正在运行的进程、就绪队列中的进程、阻塞队 列中的进程、完成的进程以及各个进程的 PCB,以便进行检查。 

C++ 银行家算法与时间片轮转调度算法结合

完整项目:C++ 银行家算法与时间片轮转调度算法结合

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define TIME_SLICE 2

// 进程状态:就绪 等待 阻塞 完成
enum process_type{
    process_type_wait = 'W',
    process_type_run = 'R',
    process_type_block = 'B',
    process_type_finish = 'F'
};

typedef struct PCB{ 
	// 进程名 
	char name;
	// 最大需求资源数
	int Max[100]; 
	// 还需要的资源数
	int Need[100];
	// 已分配的资源数 
	int Allocate[100]; 
	// 进程已运行时间 
	int run_time; 
	// 进程状态
	char state;
	// 指向下一个进程
	PCB *next; 
}PCB; 

// 系统资源的名称
char Name[100]={0};
// 系统可用资源向量 
int Available[100];
// 进程请求资源向量	
int Request[100];
// 存放系统可提供资源量
int Work[100];  
// 标记系统是否有足够的资源分配给各个进程
bool Finish[100];
// 存放安全序列
char Security[100];

// 进程的最大数
int M = 100;
// 资源的最大数
int N = 100;
// 标志是否输出
bool flag = true; 

// 函数声明
// 初始化数据
void init(PCB *list);
// 创建进程 
void create_process(PCB *list);
// 显示资源分配和进程运行情况 
void print(PCB *list);
// 试探性分配资源
void test(PCB *list);
// 试探性分配资源作废
void Retest(PCB *list);
// 利用银行家算法对申请资源进行试分
bool bank(PCB *list);
// 安全性算法
bool safe(PCB *list);
// 时间片轮转调度算法 
void round_robin(PCB *list);

// 主函数
int main(){	
	printf("-----------------------------------------------------------------------\n");
	printf("                        银行家算法的实现                               \n");
	printf("-----------------------------------------------------------------------\n\n");
	PCB *list = (PCB *)malloc(sizeof(PCB));
	if(list == NULL){
		printf("动态分配内存失败!");
	}
    list->next = NULL;
	
	srand((int)time(NULL));
	// 初始化数据
	init(list);
	// 显示资源分配和进程运行情况 
	printf("***********************************************************************\n");
	print(list);
    // 用银行家算法判定系统当前时刻是否安全,不安全就不再继续分配资源 
	if(!safe(list)) {
		exit(0);
	}
	printf("\n***********************************************************************\n");
	// 使用时间片轮转法进行进程调度 
	round_robin(list);
    system("pause");
}

// 初始化数据
void init(PCB *list){
	// m为进程数,n为系统资源种类
    int m,n;
	// 初始化系统资源种类数及各资源数 
	printf("系统可用资源种类数为:");
	scanf("%d",&n);
    getchar();
	// 系统资源种类数,赋给全局变量N,方便后续方法使用 
	N = n;
	// 资源名称
	char name;
	// 资源数 
	int number; 
	for(int i = 1;i <= n;i++){
		printf("\t资源%d的名称:",i);
		getchar();
		scanf("%c",&name);
        getchar();
		Name[i] = name;
		printf("\t资源%c的初始个数为:",name);	
		scanf("%d",&number);
        getchar();
		Available[i] = number;
	}
	// 初始化进程数及各进程的最大需求资源数 
	printf("\n请输入进程的数量:");	
	scanf("%d",&m);
	// 进程数,赋给全局变量M,方便后续方法使用 
	M = m;
	create_process(list);
}

// 创建进程 
void create_process(PCB *list){
	// 统计已分配的系统资源
	int temp[100] = {0};
	int number = 1; 
	while(number <= M){
		// 进程节点 
		PCB *p = (PCB *)malloc(sizeof(PCB));
		if(p == NULL){
			printf("动态分配内存失败!");
		}
		// 进程名 
		printf("\t请输入第%d进程的进程名:",number); 
		getchar();
		scanf("%c",&p->name);
		// 标志变量 
		bool flag;
		// 初始化各进程最大需求资源数、仍需资源数和已分配资源数
		do{
			flag = false; 
			for(int i = 1;i <= N;i++){ 
				p->Max[i] = rand()%10;
				if(p->Max[i] > Available[i]){ 
					flag = true;
					// printf("资源最大需求量大于系统中资源最大数,请重新输入!\n");
					break;	
				}
				p->Need[i] = p->Max[i];
				p->Allocate[i] = 0;		
			} 				
		}while(flag);
		// 进程已运行时间 
		p->run_time = 0; 
		// 进程状态
		p->state = process_type_wait;
		// 指向下一个进程
		p->next = NULL;
		if(list->next == NULL){
			list->next = p;
		}else{
			PCB *move = list->next;
			while(move->next != NULL){
				move = move->next;
			}
			move->next = p;	 	
		}
		number++;
	}
	printf("\n");
} 

// 显示资源分配和进程运行情况 
void print(PCB *list){
	printf("\n系统目前可用的资源(Available):\n");
	for(int i = 1;i <= N;i++){
		printf("%c  ",Name[i]);
	}
	printf("\n");
	for(int i = 1;i <= N;i++){
		printf("%d  ",Available[i]);
	}
	printf("\n\n");
	printf("系统当前的资源分配情况及进程运行情况如下:\n");
	printf("          Max        Allocate        Need\n");
	printf("进程名  ");
	//输出与进程名同行的资源名,Max、Allocate、Need下分别对应 
	for(int i = 1;i <= 3;i++){
		for(int j = 1;j <= N;j++){
			printf("%c  ",Name[j]);
		}
		printf("     "); 
	}
	printf("已运行时间   进程状态\n");
	
	// 遍历链表 
	PCB *p = list->next;
	while(p != NULL){
		//输出每个进程的Max、Allocation、Need 
		printf("  %c\t",p->name);
	    for(int j = 1;j <= N;j++)
			printf("%d  ",p->Max[j]);
		printf("     "); 
		for(int j = 1;j <= N;j++)
			printf("%d  ",p->Allocate[j]);
		printf("     ");
		for(int j = 1;j <= N;j++)
			printf("%d  ",p->Need[j]);
		printf("        ");
		printf("  %d\t  ",p->run_time); 
		printf("%c\n",p->state); 
		p = p->next;
	}
}

// 试探性分配资源
void test(PCB *list){ 
	// 请求资源的进程 
	PCB *p = list->next;
	// 更改进程信息 
	for(int i = 1;i <= N;i++){
		Available[i] -= Request[i];
		p->Allocate[i] += Request[i];
		p->Need[i] -= Request[i];
	}
}
 
// 试探性分配资源作废
void Retest(PCB *list){
 	// 请求资源的进程 
	PCB *p = list->next;
	// 与test操作相反 
	for(int i = 1;i <= N;i++){
		Available[i] += Request[i];
		p->Allocate[i] -= Request[i];
		p->Need[i] += Request[i];
	}
}

// 利用银行家算法对申请资源进行试分
bool bank(PCB *list){
    PCB *p = list->next;
    // 随机生成请求向量
	for(int i = 1;i <= N;++i){
		Request[i] = rand()%(p->Need[i]+1);
	}
	// 随机产生的请求资源数均为0,表示不理会 
	int n = 0;
	for(int i = 1;i <= N;++i){
		if(Request[i] == 0){
			n++;
		}
	}
	if(n == N){
		flag = false;
		return false;
	}
	printf("\n%c进程请求 —— ",p->name);
	for(int i = 1;i <= N;i++){
		printf("资源%c:",Name[i]);
		printf("%d   ",Request[i]); 
	}
	printf("\n\n"); 
	// 定位要求的资源数组下标 
	int num = 1;
	// 判断银行家算法的前两条件是否成立 
    for(int i = 1;i <= N;++i){
    	// 判断申请是否大于需求,若大于则出错
		if(Request[i] > p->Need[i]){ 
			printf("%c进程申请的资源大于它需要的资源\n",p->name);
			printf("分配不合理,不予分配!\n");
			return false;
		}else{
			// 判断申请是否大于当前可分配资源,若大于则出错
            if(Request[i] > Available[i]){                         
				printf("%c进程申请的资源大于系统现可利用的资源\n",p->name);
				printf("系统尚无足够资源,不予分配!\n");
				return false;
			}
		}
	}
    // 前两个条件成立,试分配资源,寻找安全序列 
	// 根据进程需求量,试分配资源
	test(list); 
	// 判断系统是否安全 
	if(!safe(list)){
		Retest(list);
		return false;
	}
	return true;
}

// 安全性算法
bool safe(PCB *list){
	// 统计未完成进程数 
	int m = 0;
	PCB *move = list->next;
	while(move != NULL && move->state != process_type_finish){
		move = move->next;
		++m;
	}
	// 初始化Work数组 
	for(int i = 1;i <= N;i++){
		Work[i] = Available[i];
	}
    // 初始化Finish数组 
    for(int i = 1;i <= M;i++){
    	if(i <= m){
    		Finish[i] = false;
		}else{
			Finish[i] = true;
		}
	} 
	// 节点位置,判断进程运行 
	int pnum = 1,apply;
	int num = 1;
	// 求安全序列 
	PCB *p = list->next; 
	while(p != NULL && pnum <= m){
		apply = 0;
		for(int i = 1;i <= N;i++){
			// 当前进程未完成并且各类资源小于或等于系统资源数 
			if(Finish[pnum] == false && p->Need[i] <= Work[i]){   
				apply++;
				// 直到每类资源尚需数都小于系统可利用资源数才可分配
				if(apply == N){  
					for(int x = 1;x <= N;x++){
						// 更新当前系统可分配资源
				        Work[x] += p->Allocate[x];
					} 
					// 更新标记数组 
					Finish[pnum] = true;
					// 更新安全序列数组 
					Security[num++] = p->name;
					// 保证每次查询均从第一个进程开始	
					pnum = 0; 
					p = list; 
				}
			}
		}
		// 查询下一进程 
		pnum++; 
		p = p->next;
	}
	for(int i = 1;i <= M;i++){
		if(Finish[i] == false){
			// 系统处于不安全状态 
			printf("系统不安全!\n");
			return false;
		}
	}
	// 如果安全,输出安全序列 
    printf("系统是安全的!\n");
    printf("存在一个安全序列:");
	for(int i = 1;i <= m;i++){
		// 输出进程运行顺序数组
		printf(" %c ",Security[i]);
		if(i < m){
			printf("->");
		} 
	}
	printf("\n");
	return true;
}

// 时间片轮转调度算法 
void round_robin(PCB *list){
    // 记录第一个结点的位置
    PCB *index = list->next;
    while (index != NULL && index->state != process_type_finish) {
    	// 判断调度后是否输出 
    	flag = true; 
		// 系统安全,进程分配到资源并运行 
		if(bank(list)){
			// 更新已运行时间
			index->run_time += TIME_SLICE;
	        // 判断该进程是否完成 
	        int num = 0;
	        for(int i = 1;i <= N;++i){
	        	if(index->Max[i] == index->Allocate[i]){
        			num++;
				}	
			}
        	// 该进程已完成 
	        if (num == N) {
	            // 修改进程状态
	            index->state = process_type_finish;
	            // 回收分配的资源
	            for(int i = 1;i <= N;i++){
					Available[i] += index->Allocate[i];
				}
	            printf("%c进程完成\n",index->name);
	        }else{
	        	// 进程未完成,进入等待 
	            index->state = process_type_wait;
	        }
	        // 当前进程已完成 
	    	if (index->state == process_type_finish){
	    		// 将已完成进程调整到已完成队列末尾 
				// 1.头指针指向首元结点的下一个结点
		        list->next = index->next;
		        // 2.遍历整个链表,将其插入到已完成队列的最尾端
		        PCB *p = list;
		        while (p->next != NULL) {
		            p = p->next;
		        }
		        p->next = index;
				index->next = NULL;
			} else {
				// 当前进程未完成 
				// 1.头指针指向首元结点的下一个结点
		        list->next = index->next;
		        // 2.遍历整个链表,将其插入到等待队列的最尾端(其后是已完成队列)
		        PCB *p = list;
		        // 2.1寻找插入位置
		        while (p->next != NULL && p->next->state != process_type_finish) {
		            p = p->next;
		        }
		        // 2.2判断插入位置
		        if (p->next == NULL) {
		            // 最后一个
		            p->next = index;
		            p->next->next = NULL;
		        }else{
		            // 不是最后一个,其后仍有结点
		            index->next = p->next;
		            p->next = index;
		        }
			}	
		}else{
			// 该进程请求资源分配会导致系统不安全或请求资源不合理 
			// 将该进程阻塞并调整到等待队列和已完成队列中间,且是阻塞队列的最后一个 
			index->state = process_type_block;
			// 当前进程未完成并处于阻塞状态 
			// 1.头指针指向首元结点的下一个结点
	        list->next = index->next;
	        // 2.遍历整个链表,将其插入到未完成队列后阻塞队列的最后一个
	        PCB *p = list;
	        // 2.1寻找插入位置
	        while (p->next != NULL && p->next->state != process_type_finish) {
	            p = p->next;
	        }
	        // 2.2判断插入位置
	        if (p->next == NULL) {
	            // 最后一个
	            p->next = index;
	            p->next->next = NULL;
	        }else{
	            // 不是最后一个,其后仍有结点
	            index->next = p->next;
	            p->next = index;
	        }
		}
		// 展示当前队列状况
		if(list->next->state != process_type_finish){
			list->next->state = process_type_run;        	
		}
		if(flag){
	        print(list);	        
			printf("\n***********************************************************************\n");	
		}
		index = list->next;
    }
}

3.3 实验结果

C++ 银行家算法与时间片轮转调度算法结合

C++ 银行家算法与时间片轮转调度算法结合

 C++ 银行家算法与时间片轮转调度算法结合

C++ 银行家算法与时间片轮转调度算法结合

 C++ 银行家算法与时间片轮转调度算法结合

 报告页面截图

C++ 银行家算法与时间片轮转调度算法结合

 C++ 银行家算法与时间片轮转调度算法结合

 C++ 银行家算法与时间片轮转调度算法结合

 C++ 银行家算法与时间片轮转调度算法结合

C++ 银行家算法与时间片轮转调度算法结合

C++ 银行家算法与时间片轮转调度算法结合

C++ 银行家算法与时间片轮转调度算法结合

注:代码借鉴于文章来源地址https://www.toymoban.com/news/detail-479476.html

到了这里,关于C++ 银行家算法与时间片轮转调度算法结合的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 银行家算法

    银行家算法(Banker’s Algorithm)是一个避免死锁(Deadlock)的著名算法,是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础,判断并保证系统的安全运行。 假设客户A、B、C 三人向银行贷款用于建房,分别需要贷款

    2024年02月02日
    浏览(18)
  • 操作系统--银行家算法

    目录 1.产生死锁的原因及必要条件   1.1产生死锁的原因   1.2产生死锁的必要条件 2.处理死锁的方法 3.银行家算法 4.安全性算法 5.算法实现        如果一个进程集合里面的每个进程都在等待这个集合中的其他一个进程(包括自身)才能继续往下执行,若无外力他们将无法推

    2024年02月01日
    浏览(14)
  • 操作系统-银行家算法

    目录 一、银行家算法 二、银行家算法的流程和数据结构 1.数据结构 2.步骤流程 3.安全性算法 三、举例 解题思路 答案 为了避免死锁,出现了银行家算法。 系统必须确保是否有足够的资源分配给一个进程,若有,再计算分配后系统是否会处于不安全状态,若安全,才会分配。

    2024年02月02日
    浏览(21)
  • 银行家算法的实验报告

    一、实验内容 银行家算法是避免死锁的一种重要方法,本实验要求编写和调试一个简单的银行家算法程序。 1.设计进程对各类资源最大申请表示及初值的确定。 2.设定系统提供资源的初始状况。 3.设定每次某个进程对各类资源的申请表示。 4.编制程序,依据银行家算法

    2023年04月26日
    浏览(22)
  • [操作系统] 银行家算法

    如果系统按照这种序列分配资源,则每个进程都能顺利完成。只要能找出一个安全序列,系统就是安全状态。 当然,安全序列可能有多个 。 此时你是一位成功的银行家,手里有100亿资金… 此时有三个企业想找你贷款,分别是企业B,企业A,企业T B:“大哥,我最多要借70亿

    2023年04月08日
    浏览(16)
  • 操作系统实验——银行家算法

    掌握银行家算法思想,并能编程实现。 1、在Linux环境下编译运行程序; 2、按照教材的算法编写; 3、(*)输入数据从文本文件中读出,不从键盘录入,数据文件格式见以下说明; 4、主要数据结构的变量名和教材中的一致,包括Available、Max、Allocation、Need、Request、Work、Fin

    2024年02月01日
    浏览(19)
  • C语言实现银行家算法

    银行家算法 最初是由荷兰计算机科学家艾兹赫尔·迪杰斯特拉(Edsger W. Dijkstra)于1965年提出的。当时他正致力于解决多道程序设计中产生的死锁问题。在多道程序设计中,由于不同进程之间共享有限的系统资源,如内存、I/O设备等,因此存在一个进程等待其他进程释放资源而

    2024年02月05日
    浏览(17)
  • 银行家算法 源码+实验报告(用了自取)

    XI`AN TECHNOLOGICAL UNIVERSITY 课程设计报告 实验课程名称 操作系统—银行家算法     专    业 :计算机科学与技术          班    级 :                姓    名 :                   学    号 :          实验学时 :                     

    2024年02月09日
    浏览(20)
  • 【操作系统原理实验】银行家算法模拟实现

    选择一种高级语言如C/C++等,编写一个银行家算法的模拟实现程序。1) 设计相关数据结构;2) 实现系统资源状态查看、资源请求的输入等模块;3) 实现资源的预分配及确认或回滚程序;4) 实现系统状态安全检查程序;5) 组装各模块成一个完整的模拟系统。 (1)设计思想: 1、

    2024年02月01日
    浏览(22)
  • 【操作系统】银行家算法个人出题例题 (含答案)

    1.银行家算法是代表性的避免死锁的算法,在进程调度中具有重要作用。请结合所学知识回答以下问题:(23分——加长版) (1)银行家算法使用的四个必要的数据结构是:可用资源向量Available,____________,分配矩阵Allocation,需求矩阵Need。(1分) (2)以下是银行家算法具体实现

    2024年02月12日
    浏览(17)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包