操作系统实验2--银行家算法

合集下载

操作系统 实验 进程调度 银行家算法 多线程编程 存储管理 磁盘调度

操作系统 实验 进程调度 银行家算法 多线程编程  存储管理 磁盘调度

实验一进程调度实验学时:2学时实验类型:设计实验要求:必修一、实验目的多道程序设计中,经常是若干个进程同时处于就绪状态,必须依照某种策略来决定那个进程优先占有处理机。

因而引起进程调度。

本实验模拟在单处理机情况下的处理机调度问题,加深对进程调度的理解。

二、实验内容1.优先权法、轮转法简化假设1)进程为计算型的(无I/O)2)进程状态:ready、running、finish3)进程需要的CPU时间以时间片为单位确定2.算法描述1)优先权法——动态优先权当前运行进程用完时间片后,其优先权减去一个常数。

2)轮转法三、流程图四、实验程序代码package进程调度;/***@author**/public class CPCB {private String name;private int time;private int count;public int getCount() {return count;}public void setCount(int count) { this.count = count;}public String getName() {return name;}public void setName(String name) { = name;}public int getTime() {return time;}public void setTime(int time) {this.time = time;}}package进程调度;/***@author**/class PCB{private String name;private int time ;private int priority ;public int getTime(){return time;}public void setTime(int time){this.time = time;}public int getPriority(){return priority;}public void setPriority(int priority){ this.priority = priority;}public String getName() {return name;}public void setName(String name) { = name;}}package进程调度;import java.util.LinkedList;/***@author**/class process{private final static int nap_time = 500;private LinkedList<PCB> queue = new LinkedList<PCB>();private LinkedList<CPCB> cqueue = new LinkedList<CPCB>();//优先权算法public void go(int p_Num) throws Exception{for(int i = 0;i<p_Num;i++){PCB pcb = new PCB();int time = (int)(Math.random()*20+1);int pri = (int)(Math.random()*20+4);pcb.setName("进程"+i);pcb.setTime(time);pcb.setPriority(pri);queue.add(pcb);}queue = this.sort(queue);int i=0;while(queue.size()!=0){PCB pcb = (PCB)queue.getFirst();System.out.println(i+"\t\t"+pcb.getName()+"运行\t"+"优先级:"+pcb.getPriority()+"---所需时间:"+pcb.getTime());// Thread.sleep(nap_time);int pre = pcb.getPriority() - 3;int time = pcb.getTime() - 1;if(time<=0){System.out.println(pcb.getName()+"\t\t进程运行结束");PCB p = (PCB)queue.removeFirst();System.out.println("移除队列的进程是\t\t"+p.getName()+"\n队列中还有"+queue.size()+"个进程\n");}else{queue.remove();pcb.setPriority(pre);pcb.setTime(time);// System.out.println("运行后:"+i+"----"+pcb.getName()+"---优先级:"+pcb.getPriority()+"---所需时间:"+pcb.getTime());queue.add(pcb);queue = this.sort(queue);}i++;}}//时间片轮转调度算法public void cycle(int p_Num) throws Exception{final int time = 3; //定义轮转时间片数for(int i = 0;i<p_Num;i++){CPCB cpcb = new CPCB();cpcb.setTime((int)(Math.random()*20)+1);cpcb.setName("进程"+i);cpcb.setCount(0);cqueue.add(cpcb);}while(cqueue.size()!=0){CPCB cpcb = (CPCB)cqueue.getFirst();while(cpcb.getCount()!=time){// Thread.sleep(nap_time);cpcb.setTime(cpcb.getTime() - 1);cpcb.setCount(cpcb.getCount()+1);for(int i=0;i<cqueue.size();i++)//输出进程运行情况{CPCB cpcb1 = (CPCB)cqueue.get(i);System.out.println(cpcb1.getName()+"\t\t所需时间片数"+cpcb1.getTime()+"\t\t已占用CPU时间片数"+cpcb1.getCount());}if(cpcb.getTime()==0){System.out.println(cpcb.getName()+"运行结束\n"+"-------------移除队列的是"+cpcb.getName()+"-------------");cqueue.removeFirst();System.out.println("-------------队列中还有"+cqueue.size()+"个进程--------------");break;}if(cpcb.getCount()==time){// cqueue.remove();System.out.println("----因为"+cpcb.getName()+"占用CPU时间片数"+cpcb.getCount()+"="+time);System.out.println(cpcb.getName()+"时间片运行结束"+cpcb.getCount()+cpcb.getTime());CPCB p = (CPCB)cqueue.removeFirst();cqueue.add(p);cpcb.setCount(0);break;}}}}public LinkedList<PCB> sort(LinkedList<PCB> processes){for(int i=0;i<processes.size();i++){PCB thread = new PCB();thread = processes.get(i);for(int j=i+1;j<processes.size();j++){if(thread.getPriority() < processes.get(j).getPriority()){PCB mythread = new PCB();mythread = thread;//thread = processes.get(j);processes.set(i, processes.get(j));processes.set(j, mythread);}}}return processes;}}package 进程调度;import java.io.BufferedReader;import java.io.InputStreamReader;/**** @author 邱福文**/public class MainFun{public void FPF(){}public static void main (String[] args) throws Exception{Integer n2;do{System.out.print("请输入进程数:");BufferedReader sin = new BufferedReader(new InputStreamReader(System.in));String str = sin.readLine();Integer n = Integer.parseInt(str);System.out.print("请输入调度算法:\n"+"1为优先权\n"+"2为轮转法\n"+"0 退出\n");BufferedReader sin2 = new BufferedReader(new InputStreamReader(System.in));String str2 = sin2.readLine();process p = new process();// do{n2 = Integer.parseInt(str2);switch(n2){case 0:break;case 1:p.go(n);break;case 2:p.cycle(n);break;default:System.out.print("输入有误请重新输入");break;}}while(n2!=0);}}五、实验结果请输入进程数:3请输入调度算法:1为优先权2为轮转法0 退出10 进程0运行优先级:19---所需时间:181 进程1运行优先级:19---所需时间:152 进程0运行优先级:16---所需时间:173 进程1运行优先级:16---所需时间:144 进程0运行优先级:13---所需时间:165 进程1运行优先级:13---所需时间:136 进程2运行优先级:10---所需时间:87 进程0运行优先级:10---所需时间:158 进程1运行优先级:10---所需时间:129 进程2运行优先级:7---所需时间:710 进程0运行优先级:7---所需时间:1411 进程1运行优先级:7---所需时间:1112 进程2运行优先级:4---所需时间:613 进程0运行优先级:4---所需时间:1314 进程1运行优先级:4---所需时间:1015 进程2运行优先级:1---所需时间:516 进程0运行优先级:1---所需时间:1217 进程1运行优先级:1---所需时间:918 进程2运行优先级:-2---所需时间:419 进程0运行优先级:-2---所需时间:1120 进程1运行优先级:-2---所需时间:821 进程2运行优先级:-5---所需时间:322 进程0运行优先级:-5---所需时间:1023 进程1运行优先级:-5---所需时间:724 进程2运行优先级:-8---所需时间:225 进程0运行优先级:-8---所需时间:926 进程1运行优先级:-8---所需时间:627 进程2运行优先级:-11---所需时间:1 进程2 进程运行结束移除队列的进程是进程2队列中还有2个进程28 进程0运行优先级:-11---所需时间:829 进程1运行优先级:-11---所需时间:530 进程0运行优先级:-14---所需时间:731 进程1运行优先级:-14---所需时间:432 进程0运行优先级:-17---所需时间:633 进程1运行优先级:-17---所需时间:334 进程0运行优先级:-20---所需时间:535 进程1运行优先级:-20---所需时间:236 进程0运行优先级:-23---所需时间:437 进程1运行优先级:-23---所需时间:1 进程1 进程运行结束移除队列的进程是进程1队列中还有1个进程38 进程0运行优先级:-26---所需时间:339 进程0运行优先级:-29---所需时间:240 进程0运行优先级:-32---所需时间:1进程0 进程运行结束移除队列的进程是进程0队列中还有0个进程请输入进程数:3请输入调度算法:1为优先权2为轮转法0 退出2进程0 所需时间片数8 已占用CPU时间片数1 进程1 所需时间片数6 已占用CPU时间片数0 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数7 已占用CPU时间片数2 进程1 所需时间片数6 已占用CPU时间片数0 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数6 已占用CPU时间片数3 进程1 所需时间片数6 已占用CPU时间片数0 进程2 所需时间片数13 已占用CPU时间片数0 ----因为进程0占用CPU时间片数3=3进程0时间片运行结束36进程1 所需时间片数5 已占用CPU时间片数1 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数6 已占用CPU时间片数0 进程1 所需时间片数4 已占用CPU时间片数2 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数6 已占用CPU时间片数0 进程1 所需时间片数3 已占用CPU时间片数3 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数6 已占用CPU时间片数0 ----因为进程1占用CPU时间片数3=3进程1时间片运行结束33进程2 所需时间片数12 已占用CPU时间片数1 进程0 所需时间片数6 已占用CPU时间片数0 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数11 已占用CPU时间片数2 进程0 所需时间片数6 已占用CPU时间片数0 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数10 已占用CPU时间片数3 进程0 所需时间片数6 已占用CPU时间片数0----因为进程2占用CPU时间片数3=3进程2时间片运行结束310进程0 所需时间片数5 已占用CPU时间片数1 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数4 已占用CPU时间片数2 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数3 已占用CPU时间片数3 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数10 已占用CPU时间片数0 ----因为进程0占用CPU时间片数3=3进程0时间片运行结束33进程1 所需时间片数2 已占用CPU时间片数1 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数3 已占用CPU时间片数0 进程1 所需时间片数1 已占用CPU时间片数2 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数3 已占用CPU时间片数0 进程1 所需时间片数0 已占用CPU时间片数3 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数3 已占用CPU时间片数0 进程1运行结束-------------移除队列的是进程1--------------------------队列中还有2个进程--------------进程2 所需时间片数9 已占用CPU时间片数1 进程0 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数8 已占用CPU时间片数2 进程0 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数7 已占用CPU时间片数3 进程0 所需时间片数3 已占用CPU时间片数0 ----因为进程2占用CPU时间片数3=3进程2时间片运行结束37进程0 所需时间片数2 已占用CPU时间片数1 进程2 所需时间片数7 已占用CPU时间片数0 进程0 所需时间片数1 已占用CPU时间片数2 进程2 所需时间片数7 已占用CPU时间片数0 进程0 所需时间片数0 已占用CPU时间片数3 进程2 所需时间片数7 已占用CPU时间片数0 进程0运行结束-------------移除队列的是进程0--------------------------队列中还有1个进程--------------进程2 所需时间片数6 已占用CPU时间片数1进程2 所需时间片数4 已占用CPU时间片数3----因为进程2占用CPU时间片数3=3进程2时间片运行结束34进程2 所需时间片数3 已占用CPU时间片数1进程2 所需时间片数2 已占用CPU时间片数2进程2 所需时间片数1 已占用CPU时间片数3----因为进程2占用CPU时间片数3=3进程2时间片运行结束31进程2 所需时间片数0 已占用CPU时间片数1进程2运行结束-------------移除队列的是进程2--------------------------队列中还有0个进程--------------请输入进程数:实验二银行家算法一、实验目的死锁会引起计算机工作僵死,因此操作系统中必须防止。

《操作系统》课程实验报告银行家算法

《操作系统》课程实验报告银行家算法

《操作系统》课程实验报告实验名称:银行家算法姓名:学号:地点:指导老师:专业班级:一、实验目的:1)对死锁避免中的银行家算法做进一步的理解。

2)加深理解死锁的概念3)加深理解安全序列和安全状态的概念4)通过编程,掌握银行家算法分配资源的一步步实现过程二、实验内容:1)给出系统可用资源向量2)给出当前状态系统中各个进程的资源分配情况3)根据系统当前资源状态和各个进程的资源分配情况,判断系统是否处于安装状态,若系统处于安全状态,给出所有的安全序列和每一个安全序列所对应的资源分配图,若系统不处于安全序列,则发出死锁警告。

三、实验主要代码/**银行家算法(实现所有存在路径的查找)*///构造进程单位struct Process{string p_name; //进程的名称int Max[N]; //进程对于各个资源的最大需求数目int Allocation[N]; //进程已经得到的各个资源的数目int Need[N]; // 进程对各个资源所需要的数目};int p_num, s_num; // 进程数、资源种类static struct Process P[N];int Available[N]; //系统中各个资源可用的数目void dfs(int step){/**银行家算法(实现所有存在路径的查找)搜寻所有的安全序列 */for (int i = 0; i < p_num; i++){back_time++; // 找到当前安全序列的时间点int flag = 0;if (vis[i]) continue;//判断现有的系统资源是否满足该进程的需求for (int j = 0; j < s_num; j++){if (Available[j] < P[i].Need[j]){flag = 1;break;}}if (flag) continue;vis[i] = true;//该进程运行完毕ans[step] = i;//将这个可以运行的进程编号存入数组当中// 回收资源for (int j = 0; j < s_num; j++)Available[j] += P[i].Allocation[j];//如果所有的进程都全部执行完毕if (step == p_num)Print(ans, p_num);dfs(step + 1);vis[i] = false;for (int j = 0; j < s_num; j++)Available[j] -= P[i].Allocation[j];}}四、实验过程分析本次实验的主要任务是实现银行家算法,通过输入当前某一时刻系统的资源数目和所有进程相关的资源信息,然后通过算法的实现判断当前系统是否处于不安全状态,如果是处于安全状态那么找到所有的安全序列。

操作系统实验二:银行家算法

操作系统实验二:银行家算法

操作系统实验⼆:银⾏家算法实验⼆银⾏家算法⼀、实验⽬的1、了解什么是操作系统安全状态和不安全状态;2、了解如何避免系统死锁;3、理解银⾏家算法是⼀种最有代表性的避免死锁的算法,掌握其实现原理及实现过程。

⼆、实验内容根据银⾏家算法的基本思想,编写和调试⼀个实现动态资源分配的模拟程序,并能够有效避免死锁的发⽣。

三、实验原理进程申请资源时,系统通过⼀定的算法判断本次申请是否不可能产⽣死锁(处于安全状态)。

若可能产⽣死锁(处于不安全状态),则暂不进⾏本次资源分配,以避免死锁。

算法有著名的银⾏家算法。

1、什么是系统的安全状态和不安全状态?所谓安全状态,是指如果系统中存在某种进程序列<P1,P2,…,Pn>,系统按该序列为每个进程分配其所需要的资源,直⾄最⼤需求,则最终能使每个进程都可顺利完成,称该进程序列<P1,P2,…,Pn,>为安全序列。

如果不存在这样的安全序列,则称系统处于不安全状态。

2、银⾏家算法把操作系统看作是银⾏家,操作系统管理的资源相当于银⾏家管理的资⾦,进程向操作系统请求分配资源相当于⽤户向银⾏家贷款。

为保证资⾦的安全,银⾏家规定:(1) 当⼀个顾客对资⾦的最⼤需求量不超过银⾏家现有的资⾦时就可接纳该顾客;(2) 顾客可以分期贷款,但贷款的总数不能超过最⼤需求量;(3) 当银⾏家现有的资⾦不能满⾜顾客尚需的贷款数额时,对顾客的贷款可推迟⽀付,但总能使顾客在有限的时间⾥得到贷款;(4) 当顾客得到所需的全部资⾦后,⼀定能在有限的时间⾥归还所有的资⾦。

操作系统按照银⾏家制定的规则设计的银⾏家算法为:(1)进程⾸次申请资源的分配:如果系统现存资源可以满⾜该进程的最⼤需求量,则按当前的申请量分配资源,否则推迟分配。

(2)进程在执⾏中继续申请资源的分配:若该进程已占⽤的资源与本次申请的资源之和不超过对资源的最⼤需求量,且现存资源能满⾜该进程尚需的最⼤资源量,则按当前申请量分配资源,否则推迟分配。

(3)⾄少⼀个进程能完成:在任何时刻保证⾄少有⼀个进程能得到所需的全部资源⽽执⾏到结束。

操作系统实验报告实验二银行家算法

操作系统实验报告实验二银行家算法

江南大学理学院实验报告课程名称:计算机操作系统实验名称:银行家算法实验日期:2013.11.29 班级:信计1103 姓名:陈鹭学号:1301110301实验报告要求:1.实验目的 2.实验内容与要求 3.流程图与模块调用 4.实验分析5.运行情况6.实验体会1.实验目的死锁会引起计算机工作僵死,因此操作系统中必须防止。

本实验的目的在于让学生独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序,了解死锁产生的条件和原因,并采用银行家算法有效地防止死锁的发生,以加深对课堂上所讲授的知识的理解。

2.实验内容与要求内容:银行家算法流程安全算法流程要求:设计有n个进程共享m个系统资源的系统,进程可动态的申请和释放资源,系统按各进程的申请动态的分配资源。

系统能显示各个进程申请和释放资源,以及系统动态分配资源的过程,便于用户观察和分析;3.流程图与模块调用数据结构1.可利用资源向量Available ,它是一个含有m个元素的数组,其中的每一个元素代表一类可利用的资源的数目,其初始值是系统中所配置的该类全部可用资源数目。

其数值随该类资源的分配和回收而动态地改变。

如果Available(j)=k,标是系统中现有Rj类资源k个。

2.最大需求矩阵Max,这是一个n×m的矩阵,它定义了系统中n个进程中的每一个进程对m类资源的最大需求。

如果Max(i,j)=k,表示进程i需要Rj类资源的最大数目为k。

3.分配矩阵Allocation,这是一个n×m的矩阵,它定义了系统中的每类资源当前一分配到每一个进程的资源数。

如果Allocation(i,j)=k,表示进程i当前已经分到Rj类资源的数目为k。

Allocation 表示进程i的分配向量,有矩阵Allocation的第i行构成。

i4.需求矩阵Need,这是一个n×m的矩阵,用以表示每个进程还需要的各类资源的数目。

如果Need (i,j)=k,表示进程i还需要Rj类资源k个,才能完成其任务。

#操作系统课程设计-银行家算法(流程图 源代码 设计报告)

#操作系统课程设计-银行家算法(流程图 源代码 设计报告)

操作系统课程设计-银行家算法(流程图+源代码+设计报告)一、实验目的:熟悉银行家算法,理解系统产生死锁的原因及避免死锁的方法,加深记意。

二、实验要求:用高级语言编写和调试一个描述银行家算法的程序。

三、实验内容:1、设计一个结构体,用于描述每个进程对资源的要求分配情况。

包括:进程名——name[5],要求资源数目——command[m](m类资源),还需要资源数目——need[m],已分配资源数目——allo[m]。

2、编写三个算法,分别用以完成:①申请资源;②显示资源;③释放资源。

(动态完成)四、程序流程图五、源程序:最新版本:bk5.c/*bk2.c::可以自定义进程及资源数目,可选择读文件或创建新文件,但不超过10,5*//*可修改# define NP 10*//* # define NS 5 */ /*资源种类*//*bk3.c::可以继续分配资源(〉2)*//*bk4.c::可保存分析结果*//*bk5.c::除以上功能外,对暂时不能分配的可以进行另外一次尝试,并恢复已分配的资源*//*四、程序流程图:五、源程序:最新版本:bk5.c/*bk2.c::可以自定义进程及资源数目,可选择读文件或创建新文件,但不超过10,5*//*可修改#define NP10*//* #define NS5*//*资源种类*//*bk3.c::可以继续分配资源(〉2)*//*bk4.c::可保存分析结果*//*bk5.c::除以上功能外,对暂时不能分配的可以进行另外一次尝试,并恢复已分配的资源*/ #include "string.h"#include "stdio.h"#include"dos.h"#include"conio.h"#define MOVEIN1#define GUIYUE2#define ACC3#define OK1#define ERROR0#define MAXSH7#define MAXSHL10#define MAXINPUT50#define maxsize 100int act;int ip=0;int line=0; /*line为要写的行号,全局变量*/int writeok;int right;char wel[30]={"Welcome To Use An_Li System"};char ente[76]={" 警告:未经作者同意不得随意复制更改!"};char rights[40]={"Copyright (c)2002"};struct date today;sssssssssssss;ttttttttttttt{int data[maxsize];int top;}stack;int emptystack(stack*S){if(S->top==48&&S->data[S->top]==35)return(1); /*35is'#'*/else return(0);}int push(stack*S,int x){if(S->top>=maxsize-1)return(-1);else{S->top++;S->data[S->top]=x;return(0);}int gettop(stack*S){return S->data[S->top];}int pop(stack*S){if(emptystack(S)){printf("the stack is empty\n");exit(1);}else S->top--;return S->data[S->top+1];}void initstack(stack*S){int i;S->top=0;S->data[S->top]=35;}/*****模拟打字机的效果*********/delay_fun(){int i;void music();for(i=0;;i++){if(wel!='\0'){delay(1000);textcolor(YELLOW);gotoxy(26+i,8);cprintf("%c",wel);printf("谢谢");printf("网络");music(1,60);}else break;}delay(500000);for(i=0;;i++){if(ente!='\0'){delay(1000);textcolor(RED);/*显示警告及版权*/gotoxy(2+i,11);cprintf("%c",ente);}else break;}delay(40000);for(i=0;;i++){if(rights!='\0'){delay(1000);textcolor(YELLOW);gotoxy(30+i,14);cprintf("%c",rights);music(1,60);}elsebreak;}getch();}/*********登陆后的效果**********/ logined(){int i;clrscr();gotoxy(28,10);textcolor(YELLOW);cprintf("程序正在载入请稍候....."); gotoxy(35,12);for(i=0;i<=50;i++){gotoxy(40,12);delay(8000);cprintf("%02d%已完成",i*2);gotoxy(i+15,13);cprintf("\n");cprintf("|");}main0();}/*********对PC扬声器操作的函数****/void music(int loop,int f)/*f为频率*/ {int i;for(i=0;i<30*loop;i++){sound(f*20);}int analys(int s,int a){int hh,pos;switch(a){case(int)'i':hh=0;break;case(int)'+':hh=1;break;case(int)'*':hh=2;break;case(int)'(':hh=3;break;case(int)')':hh=4;break;case(int)'#':hh=5;break;case(int)'E':hh=6;break;case(int)'T':hh=7;break;case(int)'F':hh=8;break;default:{printf("\n analys()分析发现不该有的字符%c!(位置:%d)",a,ip+1); writeerror('0',"\n............分析出现错误!!!");writeerror(a,"\n 错误类型: 不该有字符");printf("谢谢");printf("网");return ERROR;}}pos=(s-48)*10+hh;switch(pos){case3:case43:case63:case73:act=4;return MOVEIN;case0:case40:case60:case70:act=5;return MOVEIN;case11:case81:act=6;return MOVEIN;case92:case22:act=7;return MOVEIN;case84:act=11;return MOVEIN;/*-------------------------------------------*/case91:case94:case95:act=1;return GUIYUE;case21:act=2;return GUIYUE;case101:case102:case104:case105:act=3;return GUIYUE;case31:case32:case34:case35:act=4;return GUIYUE;case111:case112:case114:case115:act=5;return GUIYUE;case51:case52:case54:case55:act=6;return GUIYUE;/*+++++++++++++++++*/case15:return ACC;/*******************************/case6:return1;case7:case47:return2;case8:case48:case68:return3;case46:return8;case67:return9;case78:return10;default:{if(a=='#')printf("");else printf("\n analys() 分析发现字符%c 不是所期望的!(位置:%d)",a,ip+1);writeerror('0',"\n...........分析出现错误!!!");writeerror(a,"\n 错误类型: 字符");writeerror('0'," 不是所期望的!");printf("谢谢");printf("网");return ERROR;}}}int writefile(int a,char*st){FILE*fp;fp=fopen("an_slr.txt","a");{fprintf(fp,"%s",st); /*若a==-1则为添加的注释*/}else if(a==-2){getdate(&today);gettime(&now);fprintf(fp,"\n测试日期:%d-%d-%d",today.da_year,today.da_mon,today.da_day);测试时间:%02d:%02d:%02d",now.ti_hour,now.ti_min,now.ti_sec); fprintf(fp,"}else if(a>=0)fprintf(fp,"\n step:%02d,%s",a,st);writeok=1;fclose(fp);}return writeok;}int writeerror(char a,char*st) /*错误类型文件*/{FILE*fpp;fpp=fopen("an_slr.txt","a");if(fpp==0){printf("\nwrite error!!");writeok=0;}else{if(a=='0')fprintf(fpp,"%s",st); /*若a=='0' 则为添加的注释*/else fprintf(fpp,"%s\'%c\'(位置:%d)",st,a,ip+1);writeok=1;fclose(fpp);}return writeok;}/*^^^^^^^^^^^^^^^^^^^^^^*/main0(){int an,flag=1,action,lenr;char a,w[MAXINPUT];int len,s,ss,aa,ana;stack*st;char r[MAXSH][MAXSHL];/*初始化产生式*/strcpy(r[0],"S->E");strcpy(r[1],"E->E+T");strcpy(r[2],"E->T");strcpy(r[3],"T->T*F");strcpy(r[4],"T->F");strcpy(r[5],"F->(E)");strcpy(r[6],"F->i");clrscr();printf("\nplease input analyse string:\n");gets(w);len=strlen(w);w[len]='#';w[len+1]='\0';push(st,48); /*(int)0 进栈*/writefile(-1,"\n------------------------SLR(1)词法分析器-------------------------"); writefile(-1,"\n计本003 安完成于2003.01.1214:04"); writefile(-1,"\n谢谢");writefile(-1,"网");writefile(-1,"\n 以下为串");writefile(-1,w);writefile(-1,"('#'为系统添加)的分析结果:");writefile(-2,"");do{s=gettop(st);aa=(int)w[ip];action=analys(s,aa);if(action==MOVEIN){ss=48+act;push(st,aa);push(st,ss); /*if ss=4int=52*/ip++;}else if(action==GUIYUE){lenr=strlen(r[act])-3;for(an=0;an<=2*lenr-1;an++)pop(st); /*#0 */s=gettop(st); /*s=0*/push(st,(int)r[act][0]);/*将产生式左端F 进栈*/ana=analys(s,(int)r[act][0])+48;if(ana>59)printf("\分析出错:ana>59!!!");push(st,ana);/*analys(s,aa)即为goto(s',aa)*/if((line+1)%20==0){printf("\nThis screen is full,press any key to continue!!!");getche();clrscr();}printf("step%02d: %s\n",line++,r[act]);writefile(line,r[act]);}else if(action==ACC){flag=0;right=1;}else if(action==ERROR){flag=0;right=0;}/*接受成功*/else{flag=0;right=0;}/* 出错*/}while(flag==1);if(right==1)printf("\nok,输入串%s 为可接受串!!",w);if(right==0)printf("\nsorry,输入串%s 分析出错!!",w);if(writeok==1){printf("\nAnWin soft have wrote a file an_slr.txt");if(right==1)writefile(-1,"\n最终结果:输入串为可接受串!");}}main() /*主函数*/{clrscr();delay_fun();logined();}六、测试报告-操作系统课程设计-银行家算法(流程图+源代码+设计报告)六、测试报告:(测试结果保存于系统生成的an.txt 文件中)以下为课本上的实例::-------------------------------------------------------------------------------------========================银行家算法测试结果=========================-------------------------------------------------------------------------------------T0 时刻可用资源(Available)A:3,B:3,C:2测试日期:2003-6-28请求分配时间:14:07:29经测试,可为该进程分配资源。

银行家算法结果分析与实验心得

银行家算法结果分析与实验心得

银行家算法结果分析与实验心得银行家算法是一种用于避免死锁的资源分配算法,用于分配有限的可用资源给多个进程或线程以避免死锁并保证安全性。

它是由银行家提出的一种资源分配算法,主要用于操作系统中的进程管理。

下面是我对银行家算法的结果分析与实验心得:1. 结果分析银行家算法的运行结果主要包括两个方面:是否发生死锁和是否保证资源安全性。

首先,通过实验可以发现,银行家算法能够有效地避免死锁的发生。

当系统中某个进程或线程请求资源时,如果系统可用的资源数量无法满足其需求,银行家算法会判断该请求是否会导致死锁的发生,如果是则拒绝该请求,直到系统可用的资源满足该请求为止。

其次,银行家算法能够保证资源的安全性。

在银行家算法中,每一个进程或线程有一个最大资源需求量和已分配资源量,系统有一个可用资源量和已分配资源量,银行家算法通过计算当前可用资源量是否能够满足某个进程或线程的资源需求来判断是否能够分配资源给该进程或线程。

在分配之前,会先对资源的状态进行检查,如果分配该资源将使系统处于不安全状态,则不能分配。

2. 实验心得在实验中,我使用了一些简单的示例来演示银行家算法的应用,例如汽车工厂生产线、餐厅就餐服务等。

在实验过程中,我发现银行家算法的确可以有效避免死锁的发生,而且能够保证资源的安全性。

但是,在实际应用中,由于每个进程或线程的资源需求量和已分配资源量的变化是动态的,因此需要不断地进行资源状态检查和更新,这会增加一定的系统开销,降低系统的性能。

另外,银行家算法也有一些局限性,如它只适用于静态资源分配问题,即资源需求量和可用资源量都是固定的,而且每个进程或线程的最大需求量必须在分配资源前就知道。

如果资源需求量和可用资源量是动态变化的,银行家算法就无法满足需求,因此需要采用其他的算法来解决这类问题。

总之,银行家算法是一种很有用的资源分配算法,它可以有效避免死锁的发生,保证资源的安全性,但在实际应用中需要根据具体情况来选择合适的算法。

操作系统课程设计任务书

操作系统课程设计任务书

操作系统集中上机实验1:银行家算法一、目的和要求银行家算法是避免死锁的一种重要方法,本实验要求用高级语言编写和调试一个简单的银行家算法程序。

加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。

二、实验内容1.设计进程对各类资源最大申请表示及初值确定。

2.设定系统提供资源初始状况。

3.设定每次某个进程对各类资源的申请表示。

4.编制程序,依据银行家算法,决定其申请是否得到满足。

三、算法描述银行家可以把一定数量的资金供多个用户周转使用,为保证资金的安全银行家规定:1.当一个用户对资金的最大需求量不超过银行家现有的资金就要接纳该用户;2.用户可以分期贷款,但贷的总数不能超过最大需求量;3.当银行家现有的资金不能满足用户的沿需贷数时,对用户的贷款可推迟支付,但总能使用户在有限的时间里得到贷款;4.当用户得到所需的全部资金后,一定能在有限的时间里归还所有的资金。

实验2:时间片轮转法基本思想:将CPU的处理时间划分成一个个时间片,就绪队列中的诸进程轮流运行一个时间片,当时间片结束时,就强迫运行进程让出CPU,该进程进入就绪队列,等待下一次调度,同时,进程调度又去选择就绪队列中的一个进程,分配给它一个时间片,以投入运行。

在轮转法中,时间片长度的选择非常重要,将宜接影响系统开销和响应时间。

如果时间片长度很小,则调度程序剥夺处理机的次数频繁,加重系统开销;反之,如果时间片长度选择过长,比方说一个时间片就能保证就绪队列中所有进程都执行完毕,则轮转法就退化成先进先出算法。

实验3-4:抢占式(或非抢占式)优先级调度算法基本思想:该算法的基本思想是进程优先级高者优先调度,是一种常用的进程调度算法。

该算法的关键是如何确定优先数。

通常确定优先数的方法有两种,即静态法和动态法。

(1)静态优先权是在创建进程时确定的,其运行特征是优先数确定之后在整个进行运行期间不再改变。

确定静态优先权的依据有进程的类型、进程所使用的资源、进程的估计运行时间等因素。

操作系统银行家算法实验报告

操作系统银行家算法实验报告

操作系统银行家算法实验报告操作系统银行家算法实验报告引言:操作系统是计算机科学中的一个重要领域,它负责管理计算机的硬件和软件资源,以提供良好的用户体验。

在操作系统中,银行家算法是一种重要的资源分配和调度算法,它可以确保系统中的进程安全地访问资源,避免死锁的发生。

本实验旨在通过实践运用银行家算法,深入理解其原理和应用。

实验目的:1. 理解银行家算法的基本原理;2. 掌握银行家算法的实现方法;3. 分析银行家算法在资源管理中的应用。

实验过程:1. 实验环境的搭建在本次实验中,我们使用了一台运行Windows操作系统的计算机,并安装了Java开发环境。

同时,我们使用了一个模拟的资源管理系统,以便更好地理解和实践银行家算法。

2. 银行家算法的原理银行家算法是通过对系统中的资源进行合理分配,以避免死锁的发生。

它基于以下几个假设:- 每个进程对资源的最大需求量是已知的;- 系统中的资源数量是有限的;- 进程在请求资源时必须先声明其最大需求量;- 进程在释放资源后,不能再重新请求。

3. 银行家算法的实现银行家算法的实现主要包括以下几个步骤:- 初始化:获取系统中的资源总量和每个进程的最大需求量;- 安全性检查:通过模拟分配资源并检查系统是否处于安全状态,以确定是否可以满足进程的资源请求;- 资源分配:根据安全性检查的结果,决定是否分配资源给进程。

4. 银行家算法的应用银行家算法在实际应用中具有广泛的用途,尤其是在多任务操作系统中。

它可以用于资源的分配和调度,以确保系统中的进程能够安全地访问资源,避免死锁的发生。

结论:通过本次实验,我们深入了解了银行家算法的原理和应用。

银行家算法作为一种重要的资源管理和调度算法,可以有效地避免死锁的发生,提高系统的可靠性和稳定性。

在今后的学习和工作中,我们将继续深入研究操作系统相关的算法和原理,以提升自己在该领域的专业能力。

银行家算法实验报告

银行家算法实验报告

银行家算法实验报告引言:在计算机科学领域,由于资源的有限性,进程资源分配问题一直备受关注。

而银行家算法被广泛应用于操作系统中,用于确保资源的安全分配。

本文旨在介绍银行家算法的原理和应用,并通过实验报告来验证该算法的有效性和可行性。

1. 银行家算法简介银行家算法是由美国学者Dijkstra提出的一种资源分配和避免死锁的算法。

其基本思想是通过银行家的原则来避免系统陷入死锁状态,保证资源分配的安全性和可行性。

银行家算法适用于具有多个进程和多个资源的并发系统中。

2. 银行家算法原理银行家算法基于两个重要的概念:安全性和可分配性。

安全性表示在系统当前状态下,是否存在一种资源分配序列可以使系统避免死锁状态。

可分配性表示系统是否能够满足进程对资源的请求。

银行家算法的实现需要以下几个关键步骤:(1) 初始化:对每个进程设置最大需求量、已分配资源量和需求资源量。

(2) 效验:判断系统当前状态下资源是否满足所有进程的需求,即判断系统是否处于安全状态。

(3) 分配:若系统处于安全状态,则根据某种资源分配策略,为进程分配资源。

(4) 请求:进程请求资源。

(5) 回收:进程释放资源。

3. 银行家算法的实验验证为了验证银行家算法的有效性和可行性,我们设置了一个简单的实验环境,模拟一个有限的资源系统,包含3个进程和3种不同类型的资源。

实验过程如下:(1) 初始化:对每个进程设置最大需求量、已分配资源量和需求资源量。

设置3个进程的最大需求量分别为{5, 4, 3},已分配资源量分别为{1, 2, 2},需求资源量分别为{3, 2, 0}。

(2) 效验:判断系统当前状态下资源是否满足所有进程的需求。

经过实验验证,我们发现系统当前状态下资源无法满足进程2的资源需求。

为了保证系统的安全性和避免死锁,根据银行家算法原理,我们将不满足资源需求的进程2暂停,并回滚到初始状态。

重新调整资源分配后,系统进入了安全状态。

(3) 分配:为进程1和进程3分配资源。

实验二银行家算法实验报告

实验二银行家算法实验报告

实验二银行家算法实验报告一、实验目的通过本次实验,主要学习了解了银行家算法的原理和实现方式,掌握银行家算法的应用场景,了解了安全序列的概念和判断方法,并通过代码实现加深对银行家算法的理解和掌握。

二、实验过程1、阅读银行家算法的相关理论知识。

2、编写银行家算法的代码实现。

3、根据实验要求,设置不同的初始资源分配和不同的进程请求资源情况,分别计算是否存在安全序列。

三、实验结果与分析1、首先按照实验要求设置一个初始的资源分配情况:可用的资源数目:4 4 4进程数目:4各进程对三种资源的最初需要数目:Max:7 5 33 2 29 0 22 2 2已分配资源数目:Allocation:0 1 02 0 03 0 22 1 1剩余资源数目:Need: 7 4 31 2 26 0 00 1 1根据上述数据,计算出该初试分配情况下的安全序列为:1 -> 3 -> 4 -> 2。

2、然后设置一个进程请求资源的情况:进程 1 请求资源 [3,3,0],进程 2 请求资源 [1,0,1],进程 3 请求资源 [2,2,0],进程 4 请求资源 [0,0,2]。

根据银行家算法,先进行安全性检测,发现该系统不存在安全序列,因此不满足银行家算法的要求,请求不被满足。

3、接着修改初始的资源分配情况和请求的资源情况,进行比较:通过以上的实验操作,得出结论:只有当请求的资源不会导致系统不再安全时,才会满足请求。

银行家算法基于这个假设进行运算,它管理着一个可以分配的表格,该表格显示系统的各种资源已经分配和未分配的情况,并确定哪些进程可以分配资源,哪些不可以。

四、实验总结本次实验通过对银行家算法的概念、原理和应用场景的了解,对该算法有了更深的认识和理解,并通过代码实现和实验操作,进一步巩固和掌握了该算法的应用方法。

在实验过程中,也有一些需要注意的问题:如需要按照一定的顺序输入原数据,正确地计算资源分配和剩余情况;核实每个请求的资源数目是否足够,才进行安全性检测;注意计算过程中数值的准确性和解题思路的正确性等。

操作系统银行家算法实验报告_(1)

操作系统银行家算法实验报告_(1)

银行家算法实验报告【实验目的】(1)根据设计题目的要求,充分地分析和理解题目,叙述系统的要求,明确程序要求实现的功能以及限制条件。

(2)明白自己需要用代码实现的功能,清楚编写每部分代码的目的,做到有的放矢,有条理不遗漏的用代码实现银行家算法。

【实验要求】(1)了解和理解死锁;(2)理解利用银行家算法避免死锁的原理;(3)会使用某种编程语言。

【实验原理】一、安全状态指系统能按照某种顺序如<P1,P2,…,Pn>(称为<P1,P2,…,Pn>序列为安全序列),为每个进程分配所需的资源,直至最大需求,使得每个进程都能顺利完成。

二、银行家算法假设在进程并发执行时进程i提出请求j类资源k个后,表示为Requesti[j]=k。

系统按下述步骤进行安全检查:(1)如果Request i≤Need i则继续以下检查,否则显示需求申请超出最大需求值的错误。

(2)如果Request i≤Available则继续以下检查,否则显示系统无足够资源,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]-Requesti[j];(4)系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。

若安全,才正式将资源分配给进程Pi,以完成本次分配;否则,将本次的试探分配作废,恢复原来的资源分配状态,让进程Pi等待。

三、安全性算法(1)设置两个向量:①工作向量Work: 它表示系统可提供给进程继续运行所需的各类资源数目,它含有m个元素,在执行安全算法开始时,Work∶=Available;② Finish: 它表示系统是否有足够的资源分配给进程,使之运行完成。

开始时先做Finish[i]∶=false; 当有足够资源分配给进程时,再令Finish [i]∶=true。

银行家算法 实验报告

银行家算法 实验报告

淮海工学院计算机工程学院实验报告书课程名:《操作系统原理》题目:银行家算法班级:学号:姓名:一、实验目的银行家算法是操作系统中避免死锁的典型算法,本实验可以加深对银行家算法的步骤和相关数据结构用法的更好理解。

实验环境TurboC2.0/3.0或VC++6.0实验学时4学时,必做实验。

二、实验内容用C语言编写一个简单的银行家算法模拟程序,用银行家算法实现资源分配。

程序能模拟多个进程共享多种资源的情形。

进程可动态地申请资源,系统按各进程的申请动态地分配资源。

要求程序具有显示和打印各进程的某一时刻的资源分配表和安全序列;显示和打印各进程依次要求申请的资源数量以及为某进程分配资源后的有关资源数据的情况。

三、实验说明实验中进程的数量、资源的种类以及每种资源的总量Total[j]最好允许动态指定。

初始时每个进程运行过程中的最大资源需求量Max[i,j]和系统已分配给该进程的资源量Allocation[i,j]均为已知(这些数值可以在程序运行时动态输入),而算法中其他数据结构的值(包括Need[i,j]、Available[j])则需要由程序根据已知量的值计算产生。

四、实验步骤1、理解本实验中关于两种调度算法的说明。

2、根据调度算法的说明,画出相应的程序流程图。

3、按照程序流程图,用C语言编程并实现。

五、分析与思考1.要找出某一状态下所有可能的安全序列,程序该如何实现?答:要找出这个状态下的所有可能的安全序列,前提是要是使这个系统先处于安全状态,而系统的状态可通过以下来描述:进程剩余申请数=最大申请数-占有数;可分配资源数=总数-占有数之和;通过这个描述来算出系统是否安全,从而找出所有的安全序列。

2.银行家算法的局限性有哪些?答:银行家算法是一种最有代表性的避免死锁的算法。

银行家算法即把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。

操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。

银行家算法实验报告c语言

银行家算法实验报告c语言

银行家算法实验报告c语言银行家算法实验报告引言:计算机科学中的银行家算法是一种资源分配和避免死锁的算法。

它是由艾德加·戴克斯特拉(Edsger Dijkstra)在1965年提出的。

银行家算法通过判断一个系统是否处于安全状态来决定是否分配资源给进程。

本实验旨在使用C语言实现银行家算法,并通过一系列的实例来验证其有效性。

一、实验背景银行家算法是为了解决资源分配中的死锁问题而提出的。

在多进程系统中,每个进程都需要一定数量的资源来完成任务。

然而,如果资源分配不当,可能会导致死锁的发生,即所有进程都陷入无法继续执行的状态。

银行家算法通过合理地分配资源,避免了死锁的发生。

二、实验目的本实验的主要目的是通过C语言实现银行家算法,并通过实例验证其正确性和有效性。

具体而言,我们将模拟一个系统中的多个进程,并为每个进程分配资源。

然后,我们将使用银行家算法来判断系统是否处于安全状态,从而决定是否继续分配资源。

三、实验过程1. 创建进程和资源我们首先创建了5个进程和3种资源。

每个进程需要的资源数量是随机生成的,以模拟真实情况下的资源需求。

2. 分配资源根据银行家算法的原则,我们按照以下步骤来分配资源:- 首先,检查每个进程的资源需求是否小于等于系统当前可用的资源数量。

- 如果满足条件,将资源分配给该进程,并更新系统剩余资源数量。

- 如果不满足条件,暂时不分配资源给该进程,继续检查下一个进程。

3. 判断系统状态在每次资源分配后,我们需要判断系统是否处于安全状态。

为此,我们使用银行家算法的核心原则:只有当系统能够为每个进程提供所需的资源时,系统才是安全的。

我们通过遍历所有进程来检查其资源需求是否小于等于系统剩余资源数量,如果满足条件,说明系统是安全的。

4. 实例验证我们进行了多个实例验证,以确保银行家算法的正确性。

在每个实例中,我们模拟了不同的进程和资源需求,并观察系统的状态。

通过比较实验结果和预期结果,我们验证了银行家算法的有效性。

(word完整版)实验二银行家算法

(word完整版)实验二银行家算法

实验二银行家算法一、目的:加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。

要求编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用银行家算法,有效地防止和避免死锁的发生。

二、内容:银行家算法是避免死锁的一种重要方法,本实验要求编写和调试一个简单的银行家算法程序。

用银行家算法实现资源分配。

三、编程思想:首先分析银行家算法的数据结构,分析可利用资源向量Available、最大需求矩阵Max、分配矩阵Allocation、需求矩阵Need 、进程申请资源的关系,由所学知识可知;Need[i,j]=Max[I,j]—Allocation[i,j];当进程申请资源的时候;a)Request i>Need[i]。

这种情况表示该进程的资源需求已超过系统所宣布的最大值,出错。

b)Request i=Need[i]。

这种情况表示该进程现在对他所需的全部资源一次申请完成。

c)Request i〉Need[i]。

这种情况表示该进程现在对它所需资源再进行部分的申请,剩余的资源以后再次申请。

发出资源请求后;当进程pia)如果Request i<=Need[i],转向步骤b,否则显示为出错,因为所需的资源数超过事先要求的最大值。

b)Request i<=Available,便转向步骤三,否则则表示尚无足够资源,p i需等待。

c)假如系统将资源分配给p i 则:Available=Available—RequestiAllocation[i]=Allocation[i]+RequestiNeed[i]=Need[i]-Request安全性算法检查(1)设置向量:工作向量Work,它表示系统可提供给进程继续运行所需的各类资源数目,在执行安全性算法开始时,Work[]= Available[]。

Finish[],它表示系统是否有足够的资源分配给每个进程,使之运行完成。

操作系统实验二(银行家算法)实验报告

操作系统实验二(银行家算法)实验报告

实验二实验报告实验源码:#include "stdio.h"#include <iostream.h>#include <string.h>#define False 0 // 定义False#define True 1 // 定义Trueint Max[100][100] = {0}; // 各进程所需各类资源的最大需求int Avaliable[100] = {0}; // 系统可用资源char name[100] = {0}; // 资源的名称int Allocation[100][100] = {0}; // 系统已分配资源int Need[100][100] = {0}; // 还需要资源int Request[100] = {0}; // 请求资源向量int temp[100] = {0}; // 存放安全序列int Work[100] = {0}; // 存放系统可提供资源int M = 100; // 作业的最大数为100int N = 100; // 资源的最大数为100// 显示资源矩阵void showdata(){int i,j;printf("\n此时刻的资源分配情况为:\n");// 显示表头printf(" Max Allocation Need Avaliable\n");printf("PCB ");// 显示作业名称for(j = 0;j < 4;j++){for(i = 0;i < N;i++)printf("%c ",name[i]);printf(" ");}printf("\n");// 显示当前作业资源分配情况for(i = 0;i < M;i++){printf(" %d ",i);for(j = 0;j < N;j++)printf("%d ",Max[i][j]);printf(" ");for(j = 0;j < N;j++)printf("%d ",Allocation[i][j]);printf(" ");for(j = 0;j < N;j++)printf("%d ",Need[i][j]);if(i == 0){printf(" ");for (j = 0;j < N;j++)printf("%d ",Avaliable[j]);}printf("\n");}}// 进行资源分配int changdata(int i){int j;for (j = 0;j < M;j++) {Avaliable[j] = Avaliable[j] - Request[j];Allocation[i][j] = Allocation[i][j] + Request[j];Need[i][j] = Need[i][j] - Request[j];}return 1;}// 安全性算法int safe(){int i,d,k = 0,m,h,s,apply,Finish[100] = {0};int j;int flag = 0;for(i = 0;i < N;i++)Work[i] = Avaliable[i];printf(" 安全性检查\n");printf(" Work Need Allocation Work+Allocation Finish\n");printf("PCB ");// 显示作业名称for(j = 0;j < 4;j++){for(i = 0;i < N;i++)printf("%c ",name[i]);printf(" ");}printf("\n");// 显示当前作业资源分配情况for(i = 0;i < M;i++){apply = 0;for(j = 0;j < N;j++){if (Finish[i] == False && Need[i][j] <= Work[j]){apply++;if(apply == N){printf(" %d ",i);for(d = 0;d < N;d++)printf("%d ",Work[d]);printf(" ");for(d = 0;d < N;d++)printf("%d ",Need[i][d]);printf(" ");for(d = 0;d < N;d++)printf("%d ",Allocation[i][d]);printf(" ");for(m = 0;m < N;m++){Work[m] = Work[m] + Allocation[i][m];printf("%d ",Work[m]);}// 变分配数Finish[i] = True;temp[k] = i;printf(" ");printf("true ");printf("\n");i = -1;k++;flag++;}}}}for(i = 0;i < M;i++){if(Finish[i] == False){for(j = 0;j < N;j++){Avaliable[j] = Avaliable[j] + Request[j];;Allocation[i][j] = Allocation[i][j] - Request[j];;Need[i][j] = Need[i][j] + Request[j];}printf("\n系统进入不安全状态!此时系统不分配资源!\n"); // 不成功系统不安全return 0;}}printf("\n此时系统是安全的!\n"); // 如果安全,输出成功printf("安全序列为:");for(i = 0;i<M;i++) // 输出运行进程数组{printf("%d",temp[i]);if(i < M - 1)printf("->");}printf("\n");return 0;}// 利用银行家算法对申请资源对进行判定void share(){char ch;int i = 0,j = 0;ch = 'y';printf("\n请输入要求分配的资源进程号(0 - %d):",M - 1);scanf("%d",&i); // 输入须申请的资源号printf("\n请输入进程%d 申请的资源:\n",i);for(j = 0;j < N;j++){printf("%c:",name[j]);scanf("%d",&Request[j]); // 输入需要申请的资源}for (j = 0;j < N;j++){if(Request[j] > Need[i][j]) // 判断申请是否大于需求,若大于则出错{printf("\n进程%d 申请的资源大于它需要的资源",i);printf(" 分配不合理,不予分配!\n");ch = 'n';break;} else {if(Request[j] > Avaliable[j]) // 判断申请是否大于当前资源,若大于则{// 出错printf("\n进程%d 申请的资源大于系统现在可利用的资源",i);printf(" 分配出错,不予分配!\n");ch = 'n';break;}}}if(ch == 'y') {changdata(i); // 根据进程需求量变换资源showdata(); // 根据进程需求量显示变换后的资源safe(); // 根据进程需求量进行银行家算法判断}}// 主函数int main(){int t = 1,i,j,number,choice,m,n,flag;char ming;printf("\n请首先输入系统可供资源种类的数量:");scanf("%d",&n);N = n;for(i = 0;i < n;i++){printf("资源%d 的名称:",i + 1);scanf("%s",&ming);name[i] = ming;printf("资源的数量:");scanf("%d",&number);Avaliable[i] = number;}printf("\n");printf("请输入作业的数量:");scanf("%d",&m);M = m;printf("\n请输入各进程的最大需求量( %d * %d 矩阵)[Max]:\n",m,n);for(i = 0;i < m;i++)for(j = 0;j < n;j++)scanf("%d",&Max[i][j]);do{flag = 0;printf("\n请输入各进程已经申请的资源量( %d * %d 矩阵)[Allocation]:\n",m,n);for(i = 0;i < m;i++)for(j = 0;j < n;j++){scanf("%d",&Allocation[i][j]);if(Allocation[i][j] > Max[i][j])flag = 1;Need[i][j] = Max[i][j] - Allocation[i][j];}if(flag)printf("\n申请的资源大于最大需求量,请重新输入!\n\n");}while(flag);showdata(); // 显示各种资源safe(); // 用银行家算法判定系统是否安全while(1){if(t == 1){printf("\n 利用银行家算法预分配资源\n");share();t = 0;}else break;printf("\n 是否继续银行家算法?(按1 键继续,按其它任意键退出):");scanf("%d",&t);printf("\n");}return 1;}实验结果截图:运行程序:输入相应数据并完成首次自检:进程1请求资源Request(1,0,2):进程4请求资源Request(3,3,0):进程0请求资源Request(0,2,0):。

操作系统_银行家算法实验报告

操作系统_银行家算法实验报告

《计算机操作系统》课程设计题目银行家算法分析学院计算机与软件学院专业计算机科学与技术班级学号姓名指导教师起止时间一、算法综述银行家算法:在进程向系统提出资源分配请求时,算法会先对进程提出的请求进行合法性检查,即检查请求的是不大于需要的,是否不大于可利用的。

若请求合法,则进行试分配。

最后对试分配后的状态调用安全性检查算法进行安全性检查。

若安全,则分配,否则,不分配,恢复原来状态,拒绝申请。

二.算法分析2.1 银行家算法中的数据结构为资源的种类i进程的数量j可利用资源向量int Available[j]最大需求矩阵int Max[i][j]分配矩阵int Allocation[i][j]需求矩阵int need[i][j]= Max[i][j]- Allocation[i][j]申请各类资源数量int Request i[j] i进程申请j资源的数量工作向量int Work[x] int Finish[y]2.2银行家算法设Request i是进程P i的请求向量,如果Request i[j]=K,表示进程P i需要k个Rj类型的资源,当P i发出资源请求后,系统按照下述步骤进行检查:(1)如果Request i[j]≤Need[j],便转向步骤(2);否则认为出错,因为它所需要的资源数已经超过它所宣布的最大值。

(2)如果Request i[j]≤Available[j],便转向步骤(3);否则,表示尚无足够资源,P i须等待。

(3)系统试探着将资源分配给进程P i,并修改下面数据结构中的数值: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)系统执行安全性算法,检查此次资源分配后系统是否处于安全状态。

若安全,才正式将资源分配给进程P i,以完成本次分配;否则本次的试探分配作废,恢复原来的资源分配状态,让进程P i等待。

操作系统实验银行家算法

操作系统实验银行家算法

实验三银行家算法一、实验内容简要描述1.实验目标:加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。

要求编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用银行家算法,有效的防止和避免死锁的发生。

2.实验要求:银行家算法是避免死锁的一种重要方法,本实验要求用高级语言编写和调试一个简单的银行家算法程序。

用银行家算法实现资源分配。

设计五个进程{p0,p1,p2,p3,p4}共享三类资源{A,B,C}的系统,例如,{A,B,C}的资源数量分别为10,5,7。

进程可动态地申请资源和释放资源,系统按进程的申请动态地分配资源,要求程序具有显示和打印各进程的某一个时刻的资源分配表和安全序列;显示和打印各进程依次要求申请的资源号以及为某进程分配资源后的有关资源数据。

二、报告主要内容1.设计思路A、设计进程对各在资源最大申请表示及初值确定。

B、设定系统提供资源初始状态。

C、设定每次某个进程对各类资源的申请表示。

D、编制程序,依据银行家算法,决定其申请是否得到满足。

2.主要数据结构假设有M个进程N类资源,则有如下数据结构:MAX[M*N] M个进程对N类资源的最大需求量AVAILABLE[N] 系统可用资源数ALLOCATION[M*N] M个进程已经得到N类资源的资源量NEED[M*N] M个进程还需要N类资源的资源量银行家算法:设进程I提出请求Request[N],则银行家算法按如下规则进行判断。

(1)如果Request[N]<=NEED[I,N],则转(2);否则,出错。

(2)如果Request[N]<=AVAILABLE,则转(3);否则,出错。

(3)系统试探分配资源,修改相关数据:AVAILABLE=AVAILABLE-REQUESTALLOCATION=ALLOCATION+REQUESTNEED=NEED-REQUEST(4)系统执行安全性检查,如安全,则分配成立;否则试探险性分配作废,系统恢复原状,进程等待。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

姓名:刘成启学号:20101221149班级:计算机1008班指导老师:袁宁共享资源分配与银行家算法一、实验目的[问题描述]本题主要内容是模拟实现资源分配。

银行家算法是避免死锁的一种重要方法,本实验要求用高级语言编写和调试一个简单的银行家算法程序。

加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。

通过对这个算法的设计,让学生能够对书本知识有更深的理解,在操作和其它方面有更高的提升。

二、实验内容[基本要求]具体用银行家算法实现资源分配。

要求如下:(1) 设计一个3个并发进程共享3类不同资源的系统,进程可动态地申请资源和释放资源,系统按各进程的申请动态地分配资源。

(2) 设计用银行家算法,实现资源分配,应具有显示或打印各进程依次要求申请的资源数以及依次分配资源的情况。

(3) 确定一组各进程依次申请资源数的序列,输出运行结果。

[方案设计及开发过程]1银行家分配算法,顾名思义是来源于银行的借贷业务,一定数量的本金要应多个客户的借贷周转,为了防止银行加资金无法周转而倒闭,对每一笔贷款,必须考察其是否能限期归还。

在操作系统中研究资源分配策略时也有类似问题,系统中有限的资源要供多个进程使用,必须保证得到的资源的进程能在有限的时间内归还资源,以供其他进程使用资源。

如果资源分配不得到就会发生进程循环等待资源,每个进程都无法继续执行下去的死锁现象。

把个进程需要和已占有资源的情况记录在进程控制中,假定进程控制块PCB其中“状态”有就绪态、等待态和完成态。

当进程在处于等待态时,表示系统不能满足该进程当前的资源申请。

“资源需求总量”表示进程在整个执行过程中总共要申请的资源量。

显然,每个进程的资源需求总量不能超过系统拥有的资源总数, 银行算法进行资源分配可以避免死锁.2.算法描述银行家算法:设进程I提出请求Request[N],则银行家算法按如下规则进行判断。

(1)如果Request[N]<=NEED[I,N],则转(2);否则,出错。

(2)如果Request[N]<=A V AILABLE,则转(3);否则,出错。

(3)系统试探分配资源,修改相关数据:A V AILABLE=A V AILABLE-REQUESTALLOCATION=ALLOCATION+REQUESTNEED=NEED-REQUEST(4)系统执行安全性检查,如安全,则分配成立;否则试探险性分配作废,系统恢复原状,进程等待。

3.安全性检查(1)设置两个工作向量WORK=A V AILABLE;FINISH[M]=FALSE(2)从进程集合中找到一个满足下述条件的进程,FINISH[i]=FALSENEED<=WORK如找到,执行(3);否则,执行(4)(3)设进程获得资源,可顺利执行,直至完成,从而释放资源。

WORK=WORK+ALLOCATIONFINISH=TRUEGO TO 2(4)如所有的进程Finish[M]=true,则表示安全;否则系统不安全。

3.数据结构假设有M个进程N类资源,则有如下数据结构:#define W 10#define R 20int M ; //总进程数int N ; //资源种类int ALL_RESOURCE[W]; //各种资源的数目总和int MAX[W][R]; //M个进程对N类资源最大资源需求量int A V AILABLE[R]; //系统可用资源数int ALLOCATION[W][R]; //M个进程已经得到N类资源的资源量int NEED[W][R]; //M个进程还需要N类资源的资源量int Request[R]; //请求资源个数三、程序及运行情况#include<stdio.h>#define false 0#define true 1#define W 10 //进程的最大个数#define R 20 //初始化资源的最大种类个数int M=2 ; //总进程数int N=3 ; //资源种类char name[R]; //各资源的名称int MAX[W][R]; //M个进程对N类资源最大资源需求量int A V AILABLE[R]; //系统可用资源数int ALLOCATION[W][R]; //M个进程已经得到N类资源的资源量int NEED[W][R]; //M个进程还需要N类资源的资源量int Request[R]; //请求资源个数//int Work[R]; //存放系统可提供资源void Show() //显示资源矩阵{int i,j;printf("\n进程\t已占有的资源\t还需要的资源\t 可用的资源\t最大资源需求量\n");printf(" ");for(i=0;i<4;i++){for(j=0;j<N;j++){printf("%3c ",name[j]);}printf(" ");}printf("\n");for(i=0;i<M;i++){printf(" %d ",i);for(j=0;j<N;j++){printf("%3d ",ALLOCATION[i][j]);}printf(" ");for(j=0;j<N;j++){printf("%3d ",NEED[i][j]);}printf(" ");for(j=0;j<N;j++){printf("%3d ",A V AILABLE[j]);}printf(" ");for(j=0;j<N;j++){printf("%3d ",MAX[i][j]);}printf("\n");}}bool check()//安全性检查{//int WORK[R];int SAFE[W];static int P = 0;int i =0, j= 0;//循环控制bool FINISH[W] = {false,false,false,false,false,false,false,false,false,false};for(i = 0; i < M; i++)//外层循环:无论能否运行完毕,从零开始检查,直到都运行完毕或无法都无法执行{if(FINISH[i]){continue;}for(j = 0; j < N; j++){if(NEED[i][j]!=0) //>A V AILABLE[j]{break;}}SAFE[P++] = i;if(N == j) //i进程可以执行完毕,WORK = WORK + ALLOCATION,外层从零开始检查{FINISH[i] = true;//SAFE[P++] = i;for(int k = 0; k < N; k++){A V AILABLE[k]+= ALLOCATION[i][k];ALLOCATION[i][k]=0;}printf("第%d进程已经执行完毕",&i);}else{continue;}i = -1;}for(int k = 0; k < M; k++)//判断是否所有进程都运行完毕{if(!FINISH[k]){return false;}}printf("\n安全序列:{");for(i = 0; i < M; i++){printf(" %d",SAFE[i]);}printf(" }");P = 0;return true;}void main(){int i,j,flag;char ch='y';printf("===========================银行家算法============================\n\n");printf("*****************一、请分别输入%d个资源信息***********************\n",N);printf("\n");for(i=0;i<N;i++){printf("请输入第%d个资源的名称:",i);scanf("%s",&name[i]);printf("请输入第%d个资源的资源量(小于20的数):",i);scanf("%d",&A V AILABLE[i]);printf("\n");}printf("*****************二、请分别输入%d个进程信息***********************\n",M);printf("\n");do{flag=0;for(i=0;i<M;i++){for(j=0;j<N;j++){printf("请输入第%d个进程对%c类资源的最大需求量:",i,name[j]);scanf("%d",&MAX[i][j]);printf("请输入第%d个进程已分配的%c类资源的数量:",i,name[j]);scanf("%d",&ALLOCATION[i][j]);}}for(i=0;i<M&&flag!=1;i++){for(j=0;j<N&&flag!=1;j++){if(MAX[i][j]>A V AILABLE[j]||ALLOCATION[i][j]>MAX[i][j]){printf("sorry!您所输入的最大需求量超过系统的资源总量,或者申请的资源大于最大需求量!请重新输入!\n");flag=1;}else{NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];//需求的数目=最大需求-已分配A V AILABLE[j]=A V AILABLE[j]-ALLOCATION[i][j];//可分配的数目减去已经分配的数目}}}}while(flag);Show();while(ch=='y'||ch=='Y'){printf("*****************三、请输入请求资源的进程:***********************\n");scanf("%d",&i);do{flag=0;for(j=0;j<N;j++){printf("请输入请求资源%c的数量",name[j]);scanf("%d",&Request[j]);if(Request[j]>NEED[i][j]||Request[j]>A V AILABLE[j]){flag=1;printf("申请该类资源大于需求量,请重新输入!\n");}else{ALLOCATION[i][j]+=Request[j];NEED[i][j]-=Request[j];A V AILABLE[j]-=Request[j];}}check();Show();}while(flag);printf("是否继续请求资源(y/n)?");scanf("%s",&ch);}}四、实验过程中出现的问题及解决方法安全序列生成方面还要改进,是乱码。

相关文档
最新文档