死锁的避免实验报告
操作系统实验报告-死锁的避免
操作系统实验报告-死锁的避免操作系统实验(二)死锁的避免1.实验内容使用C++实现模拟随机算法和银行家算法2.实验目的(1)了解死锁的产生原因(随机算法)(2)理解死锁的解决办法(银行家算法)3.实验题目使用随机算法和银行家算法设计程序4.程序流程图主要过程流程图银行家算法流程图安全性算法流程图5.程序代码和运行结果#include <stdio.h>#include<stdlib.h> typedef struct{int A;int B;int C;}RES;#define false 0#define true 1//系统中所有进程数量#define PNUMBER 3//最大需求矩阵RES Max[PNUMBER];//已分配资源数矩阵RES Allocation[PNUMBER];//需求矩阵RES Need[PNUMBER];//可用资源向量RES Available={0,0,0};//安全序列int safe[PNUMBER];void setConfig(){int i=0,j=0;printf("================开始手动配置资源==================\n");//可分配资源printf("输入可分配资源\n");scanf("%d%d%d",&Available.A,&Available.B,&Available.C);//最大需求矩阵MAXprintf("输入最大需求矩阵%dx%d\n",PNUMBER,PNUMBER );for (i=0;i<PNUMBER;i++){scanf("%d%d%d",&Max[i].A,&Max[i].B,&Max[i].C);}//已分配矩阵Allocprintf("输入已分配矩阵%dx%d\n",PNUMBER,PNUMBER);for (i=0;i<PNUMBER;i++){scanf("%d%d%d",&Allocation[i].A,&Allocation[i].B,&Allocation[i].C);}//需求矩阵printf("输入需求矩阵%dx%d\n",PNUMBER,PNUMBER);for (i=0;i<PNUMBER;i++){scanf("%d%d%d",&Need[i].A,&Need[i].B,&Need[i].C);}printf("================结束配置资源==================\n");}void loadConfig(){FILE *fp1;if ((fp1=fopen("config.txt","r"))==NULL){printf("没有发现配置文件,请手动输入\n");setConfig();}else{int i=0;printf("发现配置文件,开始导入..\n");//可分配资源fscanf(fp1,"%d%d%d",&Available.A,&Available.B,&Available.C);//最大需求矩阵MAXfor (i=0;i<PNUMBER;i++){fscanf(fp1,"%d%d%d",&Max[i].A,&Max[i].B,&Max[i].C);}//已分配矩阵Allocfor (i=0;i<PNUMBER;i++){fscanf(fp1,"%d%d%d",&Allocation[i].A,&Allocation[i].B,&Allocation[i].C);}//需求矩阵for (i=0;i<PNUMBER;i++){fscanf(fp1,"%d%d%d",&Need[i].A,&Need[i].B,&Need[i].C);}}}//试探分配void ProbeAlloc(int process,RES *res){Available.A -= res->A;Available.B -= res->B;Available.C -= res->C;Allocation[process].A += res->A;Allocation[process].B += res->B;Allocation[process].C += res->C;Need[process].A -= res->A;Need[process].B -= res->B;Need[process].C -= res->C;}//若试探分配后进入不安全状态,将分配回滚void RollBack(int process,RES *res){Available.A += res->A;Available.B += res->B;Available.C += res->C;Allocation[process].A -= res->A;Allocation[process].B -= res->B;Allocation[process].C -= res->C;Need[process].A += res->A;Need[process].B += res->B;Need[process].C += res->C;}//安全性检查bool SafeCheck(){RES Work;Work.A = Available.A;Work.B = Available.B;Work.C = Available.C;bool Finish[PNUMBER] = {false,false,false};int i;int j = 0;for (i = 0; i < PNUMBER; i++){//是否已检查过if(Finish[i] == false){//是否有足够的资源分配给该进程if(Need[i].A <= Work.A && Need[i].B <= Work.B && Need[i].C <= Work.C){//有则使其执行完成,并将已分配给该进程的资源全部回收Work.A += Allocation[i].A;Work.B += Allocation[i].B;Work.C += Allocation[i].C;Finish[i] = true;safe[j++] = i;i = -1; //重新进行遍历}}}//如果所有进程的Finish向量都为true则处于安全状态,否则为不安全状态for (i = 0; i < PNUMBER; i++){if (Finish[i] == false){return false;}}return true;}//资源分配请求bool request(int process,RES *res){//request向量需小于Need矩阵中对应的向量if(res->A <= Need[process].A && res->B <= Need[process].B && res->C <=Need[process].C){//request向量需小于Available向量if(res->A <= Available.A && res->B <= Available.B && res->C <= Available.C){//试探分配ProbeAlloc(process,res);//如果安全检查成立,则请求成功,否则将分配回滚并返回失败if(SafeCheck()){return true;}else{printf("安全性检查失败。
操作系统实验报告-利用银行家算法避免死锁
创作时间:二零二一年六月三十日计算机把持系统实验陈说之马矢奏春创作题目利用银行家算法防止死锁一、实验目的:1、加深了解有关资源申请、防止死锁等概念, 并体会和了解死锁和防止死锁的具体实施方法.2、要求编写和调试一个系统静态分配资源的简单模拟法式, 观察死锁发生的条件, 并采纳银行家算法, 有效的防止和防止死锁的发生.二、实验内容:用银行家算法实现资源分配:设计五个进程{p0,p1,p2,p3,p4}共享三类资源{A,B,C}的系统, 例如, {A,B,C}的资源数量分别为10, 5, 7.进程可静态地申请资源和释放资源, 系统按进程的申请静态地分配资源, 要求法式具有显示和打印各进程的某一个时刻的资源分配表和平安序列;显示和打印各进程依主要求申请的资源号以及为某进程分配资源后的有关资源数据.三、问题分析与设计:1、算法思路:先对用户提出的请求进行合法性检查, 即检查请求是否年夜于需要的, 是否年夜于可利用的.若请求合法, 则进行预分配, 对分配后的状态调用平安性算法进行检查.若平安, 则分配;若不服安, 则拒绝申请, 恢复到原来的状态, 拒绝申请.2、银行家算法步伐:(1)如果Requesti<or =Need,则转向步伐(2);否则, 认为犯错, 因为它所需要的资源数已超越它所宣布的最年夜值.(2)如果Request<or=Available,则转向步伐(3);否则, 暗示系统中尚无足够的资源, 进程必需等候.(3)系统试探把要求的资源分配给进程Pi,并修改下面数据结构中的数值:Available=Available-Request[i];Allocation=Allocation+Request;Need=Need-Request;(4)系统执行平安性算法, 检查此次资源分配后, 系统是否处于平安状态.3、平安性算法步伐:(1)设置两个向量①工作向量Work.它暗示系统可提供进程继续运行所需要的各类资源数目, 执行平安算法开始时, Work=Allocation;②布尔向量Finish.它暗示系统是否有足够的资源分配给进程, 使之运行完成, 开始时先做Finish[i]=false, 当有足够资源分配给进程时, 令Finish[i]=true.(2)从进程集合中找到一个能满足下述条件的进程:①Finish[i]=false②Need<or=Work如找到, 执行步伐(3);否则, 执行步伐(4).(3)当进程P获得资源后, 可顺利执行, 直至完成, 并释放出分配给它的资源, 故应执行:Work=Work+Allocation;Finish[i]=true;转向步伐(2).(4)如果所有进程的Finish[i]=true,则暗示系统处于平安状态;否则, 系统处于不服安状态.4、流程图:系统主要过程流程图银行家算法流程图平安性算法流程图5、主要数据结构假设有M个进程N类资源, 则有如下数据结构:int max[M*N] M个进程对N类资源的最年夜需求量int available[N] 系统可用资源数int allocated[M*N] M个进程已经获得N类资源的资源量int need[M*N] M个进程还需要N类资源的资源量int worked[] 系统提供给进程继续运行所需的各类资源数目四、源代码import java.awt.*;import javax.swing.*;import java.util.*;import java.awt.event.*;import javax.swing.border.*;public class OsBanker extends JFrame { // 界面设计JLabel labelInfo;JLabel labelInfo1;int resourceNum, processNum;int count = 0;JButton buttonRequest, buttonSetInit, button, button1, buttonsearch,button2;JTextField tf1, tf2;JTextField[] textAvailable;JTextField[][] textAllocation;JTextField[][] textNeed;JTextField textProcessName;JTextField[] textRequest;int available[];int max[][];int need[][];int allocated[][];int SafeSequence[];int request[];boolean Finish[];int worked[];boolean flag = false;JFrame f1;JFrame f2;JFrame f3;JTextArea jt;void display() {Border border = BorderFactory.createLoweredBevelBorder(); Border borderTitled = BorderFactory.createTitledBorder(border, "按钮区"); textAvailable = new JTextField[5];textAllocation = new JTextField[6][5];textNeed = new JTextField[6][5];textProcessName = new JTextField("");textProcessName.setEnabled(false);textRequest = new JTextField[5];tf1 = new JTextField(20);tf2 = new JTextField(20);labelInfo = new JLabel("请先输入资源个数和进程个数(1~6), 后单击确定");JPanel contentPane;contentPane = (JPanel) this.getContentPane(); contentPane.setLayout(null);contentPane.setBackground(Color.pink);labelInfo.setBounds(50, 10, 300, 40);labelInfo.setOpaque(true);labelInfo.setForeground(Color.red);labelInfo.setBackground(Color.pink);contentPane.add(labelInfo, null);JLabel b1 = new JLabel("资源个数:");b1.setForeground(Color.blue);JLabel b2 = new JLabel("进程个数:");b2.setForeground(Color.blue);b1.setBounds(50, 80, 80, 30);contentPane.add(b1, null);tf1.setBounds(180, 80, 170, 30);contentPane.add(tf1, null);b2.setBounds(50, 150, 80, 30);contentPane.add(b2, null);tf2.setBounds(180, 150, 170, 30);contentPane.add(tf2, null);button1 = new JButton("确定");button = new JButton("重置");button1.setBounds(80, 200, 80, 30);contentPane.add(button1, null);button.setBounds(220, 200, 80, 30);contentPane.add(button, null);this.setSize(400, 300);this.setResizable(false);this.setTitle("银行家算法(SXJ)");this.setLocationRelativeTo(null);this.setDefaultClo搜索引擎优化peration(EXIT_ON_CLOSE); this.setVisible(true);f1 = new JFrame();labelInfo1 = new JLabel("请先输入最年夜需求和分配矩阵, 然后单击初始化");JPanel contentPane1;contentPane1 = (JPanel) f1.getContentPane();contentPane1.setLayout(null);contentPane1.setBackground(Color.pink);labelInfo1.setOpaque(true);labelInfo1.setBounds(75, 10, 400, 40);labelInfo1.setBackground(Color.pink);labelInfo1.setForeground(Color.blue);contentPane1.add(labelInfo1, null);JLabel labelAvailableLabel = new JLabel("AllResource:"); JLabel labelNeedLabel = new JLabel("MaxNeed:");JLabel labelAllocationLabel = new JLabel("allocated:"); JLabel labelRequestLabel = new JLabel("request process:"); labelNeedLabel.setBounds(75, 90, 100, 20);// x,y,width,heightcontentPane1.add(labelNeedLabel, null); labelAllocationLabel.setBounds(75, 240, 100, 20); contentPane1.add(labelAllocationLabel, null); labelAvailableLabel.setBounds(75, 70, 100, 20); contentPane1.add(labelAvailableLabel, null); labelRequestLabel.setBounds(75, 400, 100, 20); contentPane1.add(labelRequestLabel, null);JLabel[] labelProcessLabel1 = { new JLabel("进程1"), new JLabel("进程2"),new JLabel("进程3"), new JLabel("进程4"), new JLabel("进程5"),new JLabel("进程6") };JLabel[] labelProcessLabel2 = { new JLabel("进程1"), newJLabel("进程2"),new JLabel("进程3"), new JLabel("进程4"), new JLabel("进程5"),new JLabel("进程6") };JPanel pPanel1 = new JPanel(), pPanel2 = new JPanel(), pPanel3 = new JPanel(), pPanel4 = new JPanel();pPanel1.setLayout(null);pPanel2.setLayout(null);/** pPanel4.setLayout(null); pPanel4.setBounds(440,120,90,270);* pPanel4.setBorder(borderTitled);*/buttonSetInit = new JButton("初始化");buttonsearch = new JButton("检测平安性");button2 = new JButton("重置");buttonRequest = new JButton("请求资源");buttonSetInit.setBounds(420, 140, 100, 30);contentPane1.add(buttonSetInit, null);buttonsearch.setBounds(420, 240, 100, 30);contentPane1.add(buttonsearch, null);button2.setBounds(420, 340, 100, 30);contentPane1.add(button2, null);buttonRequest.setBounds(420, 425, 100, 30);contentPane1.add(buttonRequest, null);for (int pi = 0; pi < 6; pi++) {labelProcessLabel1[pi].setBounds(0, 0 + pi * 20, 60, 20); labelProcessLabel2[pi].setBounds(0, 0 + pi * 20, 60, 20); }pPanel1.setBounds(75, 120, 60, 120);pPanel2.setBounds(75, 270, 60, 120);for (int pi = 0; pi < 6; pi++) {pPanel1.add(labelProcessLabel1[pi], null);pPanel2.add(labelProcessLabel2[pi], null);}contentPane1.add(pPanel1);contentPane1.add(pPanel2);contentPane1.add(pPanel4);for (int si = 0; si < 5; si++)for (int pi = 0; pi < 6; pi++) {textNeed[pi][si] = new JTextField();textNeed[pi][si].setBounds(150 + si * 50, 120 + pi * 20, 50, 20); textNeed[pi][si].setEditable(false);textAllocation[pi][si] = new JTextField();textAllocation[pi][si].setBounds(150 + si * 50, 270 + pi * 20,50, 20);textAllocation[pi][si].setEditable(false);}for (int si = 0; si < 5; si++) {textAvailable[si] = new JTextField();textAvailable[si].setEditable(false);textAvailable[si].setBounds(150 + si * 50, 70, 50, 20); textRequest[si] = new JTextField();textRequest[si].setEditable(false);textRequest[si].setBounds(150 + si * 50, 430, 50, 20); contentPane1.add(textAvailable[si], null);contentPane1.add(textRequest[si], null);}for (int pi = 0; pi < 6; pi++)for (int si = 0; si < 5; si++) {contentPane1.add(textNeed[pi][si], null);contentPane1.add(textAllocation[pi][si], null);}textProcessName.setBounds(80, 430, 50, 20);contentPane1.add(textProcessName, null);f1.setSize(550, 500);f1.setResizable(false);f1.setTitle("银行家算法(SXJ)");f1.setLocationRelativeTo(null);f1.setDefaultClo搜索引擎优化peration(EXIT_ON_CLOSE);// f1.setVisible(true);f1.setVisible(false);f2 = new JFrame("平安序列显示框");jt = new JTextArea(75, 40);jt.setBackground(Color.pink);jt.setForeground(Color.blue);JScrollPane scrollPane = new JScrollPane(jt); // 加滚动条scrollPane.setBorder(BorderFactory.createLoweredBevelBord er());// 鸿沟(f2.getContentPane()).add(scrollPane);f2.setSize(450, 400);f2.setResizable(false);f2.setDefaultClo搜索引擎优化peration(EXIT_ON_CLOSE);f2.setVisible(false);buttonSetInit.setEnabled(false);buttonRequest.setEnabled(false);buttonsearch.setEnabled(false);button1.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {// labelInfo.setText("请先初始化allocated和Maxneed, 后单击初始化按钮");f1.setVisible(true);buttonSetInit.setEnabled(true);resourceNum = Integer.parseInt(tf1.getText()); processNum = Integer.parseInt(tf2.getText());for (int i = 0; i < processNum; i++) {for (int j = 0; j < resourceNum; j++) {textNeed[i][j].setEditable(true);textAllocation[i][j].setEditable(true);textAvailable[j].setEditable(true);}}}});buttonSetInit.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) {Init();buttonsearch.setEnabled(true);}});buttonsearch.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) {count = 0;SafeSequence = new int[processNum];worked = new int[resourceNum];Finish = new boolean[processNum];copyVector(worked, available);Safety(0);jt.append("平安序列数量:" + count);if (flag) {labelInfo1.setText("以后系统状态:平安");f2.setVisible(true);buttonRequest.setEnabled(true);textProcessName.setEnabled(true);for (int i = 0; i < resourceNum; i++) {textRequest[i].setEditable(true);}} else {labelInfo1.setText("以后系统状态:不服安");}buttonSetInit.setEnabled(false);}});buttonRequest.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) {count = 0;for (int i = 0; i < processNum; i++) {Finish[i] = false;}jt.setText("");flag = false;RequestResource();}});button2.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) {/** tf1.setText(""); tf2.setText("");*/f2.setVisible(false);jt.setText("");for (int i = 0; i < processNum; i++) {for (int j = 0; j < resourceNum; j++) {textNeed[i][j].setText("");textAllocation[i][j].setText("");textAvailable[j].setText("");textRequest[j].setText("");// textNeed[i][j].setEditable(false);// textAllocation[i][j].setEditable(false);// textAvailable[j].setEditable(false);textRequest[j].setEditable(false);textProcessName.setText("");Finish[i] = false;}}flag = false;buttonsearch.setEnabled(false);// labelInfo.setText("请先输入资源个数和进程个数, 后单击确定");}});button.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {tf1.setText("");tf2.setText("");f2.setVisible(false);jt.setText("");flag = false;}});}void copyVector(int[] v1, int[] v2) { for (int i = 0; i < v1.length; i++) v1[i] = v2[i];}void Add(int[] v1, int[] v2) {for (int i = 0; i < v1.length; i++) v1[i] += v2[i];}void Sub(int[] v1, int[] v2) {for (int i = 0; i < v1.length; i++) v1[i] -= v2[i];}boolean Smaller(int[] v1, int[] v2) { boolean value = true;for (int i = 0; i < v1.length; i++)if (v1[i] > v2[i]) {value = false;break;}return value;}public static void main(String[] args) {OsBanker ob = new OsBanker();ob.display();// System.out.println(" "+count);}void Init() // 初始化把持矩阵{available = new int[resourceNum];for (int i = 0; i < resourceNum; i++) {available[i] = Integer.parseInt(textAvailable[i].getText());}max = new int[processNum][resourceNum];allocated = new int[processNum][resourceNum];need = new int[processNum][resourceNum];for (int i = 0; i < processNum; i++) {for (int j = 0; j < resourceNum; j++) {max[i][j] = Integer.parseInt(textNeed[i][j].getText()); allocated[i][j] = Integer.parseInt(textAllocation[i][j] .getText());}}for (int i = 0; i < resourceNum; i++)for (int j = 0; j < processNum; j++)need[j][i] = max[j][i] - allocated[j][i];for (int i = 0; i < resourceNum; i++)for (int j = 0; j < processNum; j++) {available[i] -= allocated[j][i];if (available[i] < 0) {labelInfo.setText("您输入的数据有误,请重新输入");}}}void Safety(int n) // 查找所有平安序列{if (n == processNum) {count++;for (int i = 0; i < processNum; i++) {jt.append("进程" + (SafeSequence[i] + 1) + " "); }jt.append("\n");flag = true;return;}for (int i = 0; i < processNum; i++) {if (Finish[i] == false) {boolean OK = true;for (int j = 0; j < resourceNum; j++) {if (need[i][j] > worked[j]) {OK = false;break;}}if (OK) {for (int j = 0; j < resourceNum; j++) {worked[j] += allocated[i][j];}Finish[i] = true;SafeSequence[n] = i;Safety(n + 1);Finish[i] = false;SafeSequence[n] = -1;// num++;for (int j = 0; j < resourceNum; j++) {worked[j] -= allocated[i][j];}}}}}void RequestResource() { // 请求资源jt.setText("");int processname = (Integer.parseInt(textProcessName.getText()) - 1);request = new int[resourceNum];for (int i = 0; i < resourceNum; i++) {request[i] = Integer.parseInt(textRequest[i].getText());}if (!Smaller(request, need[processname])) {labelInfo.setText("资源请求不符该进程的需求量.");} else if (!Smaller(request, available)) {labelInfo1.setText("可用资源缺乏以满足请求,进程需要等} else {Sub(available, request);Add(allocated[processname], request);Sub(need[processname], request);copyVector(worked, available);Safety(0);if (flag) {labelInfo1.setText("可立即分配给该进程!");} else {labelInfo1.setText("分配后招致系统处于不服安状态!,不成立即分配");Add(available, request);Sub(allocated[processname], request);Add(need[processname], request);}}// }}}五、实验结果:初始界面:检测平安性:请求资源:(1)进程2(1, 0, 2)(2)进程5(3, 3, 0)(3)进程1(0, 2, 0)六、遇到的问题及缺乏之处:1、法式编写的时候规定最年夜资源数和最年夜进程数均<=6.2、法式直接初始化了6个进程框, 既浪费了内存空间, 又对可视化界面的美观造成影响.3、未对输入异常进行处置:比如在请求资源的第一个方框中只能填入进程的数字编号, 当填入的为非整数时, 法式会抛出异常.4、未解决进程名中对字符串的处置, 直接固定进程名为数字, 用户不能直接输入原有的进程名, 造成欠好的用户体验.。
操作系统实验报告 预防进程死锁的银行家算法
操作系统实验预防进程死锁的银行家算法一、需求分析:1、实验目的:通过这次实验,加深对进程死锁的理解,进一步掌握进程资源的分配、死锁的检测和安全序列的生成方法。
2、问题描述:设计程序模拟预防进程死锁的银行家算法的工作过程。
假设系统中有n个进程P1, … ,P n,有m类可分配的资源R1, … ,R m,在T0时刻,进程P i分配到的j类资源为Allocation ij个,它还需要j类资源Need ij个,系统目前剩余j类资源Work j个,现采用银行家算法进行进程资源分配预防死锁的发生。
3、程序要求:1)判断当前状态是否安全,如果安全给出安全序列;如果不安全给出理由。
2)对于下一个时刻T1,某个进程P k会提出请求Request(R1, … ,R m),判断分配给P k进程请求的资源之后系统是否安全。
3)输入:进程个数n,资源种类m,T0时刻各个进程的资源分配情况(可以运行输入,也可以在程序中设置);4)输出:如果安全,输出安全的进程序列,不安全则提示信息。
二、概要设计:1、进程调度的实现过程2、程序中的变量及数据结构struct ResItem{string Name;int Number;}; //资源项typedef vector<ResItem> Resource;struct Progress{string Name;Resource Max; //最大需求Resource Allocation; //分配Resource Need; //需求}; //进程vector <Progress> Progresses; //所有进程vector <ResItem> Available; //可利用资源向量vector <Progress> SafeOrder; //安全序列3、主要函数//初始化数据void InitData(int &n);//判断rs1是否小于等于rs2,是返回true,否则返回falseinline bool LessThan(Resource rs1,Resource rs2);//安全性算法bool SafeAlg();//银行家算法bool BankerAlg(Resource request,Progress &pro);4、主函数int main(){int n;InitData(n);cout<<"\n\n=============================================\n ";if(SafeAlg()){cout<<"由安全性检查可知:可以找到一个安全序列为:{";for(int i = 0 ; i < SafeOrder.size(); i++)cout<<SafeOrder[i].Name<<",";cout<<"}。
实验三 死锁的检测与避免
实验三死锁的检测与避免1.实验目的通过本实验,使学生进一步了解死锁、系统安全与不安全和资源动态分配的概念,学会编程实现银行家算法检验系统状态是否安全的方法,从而为将来在实际系统中使用该方法打下基础。
2.实验内容1.输入并显示资源类型数,进程数,每类资源的个体数;2.输入每个进程对每类资源的最大需求量,已分量,算出其剩余需求量。
算出系统每类资源的当前剩余量;显示输入和计算出的数据;3.按银行家算法检测系统当前是否处于安全状态,若是,往下;若否,转1,重新设置数据;4.给出某个进程的资源分配请求,按死锁避免方法检测可否将资源分配给它?若可,输出一个进程安全序列、资源分配成功的说明和新的系统资源分配状态表;若否,输出“资源分配失败”和失败的原因:①,申请量大于系统的当前剩余量,②,申请量大于自己的剩余需求量,③,若分配系统将处于不安全状态。
4.实验方法和步骤(含设计)初始化算法流程图:银行家算法流程图:安全性算法流程图:源代码:#include<iostream>using namespace std;#define MAXPROCESS 50 //最大进程数#define MAXRESOURCE 100 //最大资源数int AVAILABLE[MAXRESOURCE]; //可用资源数组int MAX[MAXPROCESS][MAXRESOURCE]; //最大需求矩阵int ALLOCATION[MAXPROCESS][MAXRESOURCE]; //分配矩阵int NEED[MAXPROCESS][MAXRESOURCE]; //需求矩阵intREQUEST[MAXPROCESS][MAXRESOURCE]; //进程需要资源数bool FINISH[MAXPROCESS]; //系统是否有足够的资源分配int p[MAXPROCESS]; //记录序列int m,n; //m个进程,n个资源void Init();bool Safe();void Bank();int main(){ Init();//初始化函数Safe();//安全性检测函数Bank();//银行家算法 }void Init(){ int i,j;cout<<"请输入进程的数目:";cin>>m;cout<<"请输入资源的种类:";cin>>n;cout<<"请输入每个进程最多所需的各资源数,按照"<<m<<"x"<<n<<"矩阵输入"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++)cin>>MAX[i][j];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(NEED[i][j]<0){cout<<"您输入的第"<<i+1<<"个进程所拥有的第"<<j+1<<"个资源数错误,请重新输入:"<<endl;j--; continue; } } }cout<<"请输入各个资源现有的数目:"<<endl;for(i=0;i<n;i++){ cin>>AVAILABLE[i];}}void Bank(){ int i,cusneed;char again;while(1){cout<<"请输入要申请资源的进程号(注:第1个进程号为0,依次类推)"<<endl; cin>>cusneed;cout<<"请输入进程所请求的各资源的数量"<<endl;for(i=0;i<n;i++){ cin>>REQUEST[cusneed][i];}for(i=0;i<n;i++){ if(REQUEST[cusneed][i]>NEED[cusneed][i]){ cout<<"您输入的请求数超过进程的需求量!请重新输入!"<<endl;continue;}if(REQUEST[cusneed][i]>AVAILABLE[i]){ cout<<"您输入的请求数超过系统有的资源数!请重新输入!"<<endl;continue;}}for(i=0;i<n;i++){ AVAILABLE[i]-=REQUEST[cusneed][i];ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];NEED[cusneed][i]-=REQUEST[cusneed][i]; }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];} }for(i=0;i<m;i++){ FINISH[i]=false;}cout<<"您还想再次请求分配吗?是请按y/Y,否请按其它键"<<endl;cin>>again;if(again=='y'||again=='Y'){ continue;} break; }}bool Safe(){ int i,j,k,l=0;int Work[MAXRESOURCE]; /*工作数组*/for(i=0;i<n;i++) 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{ for(j=0;j<n;j++){ if(NEED[i][j]>Work[j]){ break;} }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<<"安全序列:"<<endl;for(i=0;i<l;i++){ cout<<p[i];if(i!=l-1){ cout<<"-->"; } }cout<<""<<endl;return true;} }cout<<"系统是不安全的"<<endl;return false; }数据结构设计:1.可利用资源向量矩阵AVAILABLE。
实验报告(死锁的避免)
三、程序设计和说明
1.算法描述
2.算法实现
四、实课程实验报告
实验名称:死锁的避免
姓名:
学号:
专业:
五邑大学计算机学院
一、实验目的
加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。
二、实验内容
编写一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用银行家算法有效地避免死锁的发生。实验要求设计一个有三类资源A、B、C的系统,它们的资源总量分别为10、5、7,资源由五个进程p0、p1、p2、p3、p4共享。假设当前的资源分配状态为:
实验五 死锁避免的算法
实验五 死锁避免的算法【实验目的】1、 了解死锁避免的原理。
2、 研究银行家算法的实现方法。
【实验内容】编程实现银行家算法。
【实验报告】1、 列出调试通过程序的清单,并附上文档说明。
2、 总结上机调试过程中所遇到的问题和解决方法及感想。
【实验相关资料】一、死锁概念多个并发进程,每个进程占有部分资源,又都等待其它进程释放所占资源,造成均不能向前推进的现象。
二、死锁的避免死锁避免原理就是使系统始终处于安全状态。
安全状态:所谓安全状态是指能够找到一个安全序列,系统能够按照这个安全序列依次为进程分配资源,使所有进程都能执行完毕,如果找不到这样的安全序列,系统就处于不安全状态。
三、银行家算法银行家算法要求每个进程的最大资源需求,其基本思想是:始终保持系统处于安全状态,当进程提出资源请求时,系统先进行预分配,再判断系统分配后是否仍然处于安全状态。
如果仍然处于安全状态,就进行实际分配;如果处于不安全状态,则拒绝该进程的资源请求。
四、银行家算法相关数据结构1. 最大需求矩阵:d (t)=⎪⎪⎪⎪⎪⎭⎫ ⎝⎛⋅⋅⋅⋅nm n n m m d d d d d d d d d .........212222111211 其中,行表示进程,列表示资源,如:d ij =5表示第 i 个进程最多需要j 类资源5个。
2. 资源分配矩阵:a(t)=⎪⎪⎪⎪⎪⎭⎫ ⎝⎛⋅⋅⋅⋅nm n n m m a a a a a a a a a .........212222111211 元素a ij =8表示分配给第 i 进程8个j 类资源。
3. 需求矩阵:b(t)=⎪⎪⎪⎪⎪⎭⎫ ⎝⎛⋅⋅⋅⋅nm n n m m b b b b b b b b b .........212222111211 元素b ij =3表示第i 类进程还需要3个j 类资源。
最大需求矩阵=分配矩阵+需求矩阵,即d(t)=a(t)+b(t)。
实验三 死锁的避免--银行家算法
实验三死锁的避免――银行家算法一、实验目的1.掌握死锁产生的原因。
2.掌握银行家算法。
3.能使用高级语言模拟实现银行家算法。
二、相关数据结构1.可利用资源向量Available ,它是一个含有m个元素的数组,其中的每一个元素代表一类可利用的资源的数目,其初始值是系统中所配置的该类全部可用资源数目。
其数值随该类资源的分配和回收而动态地改变。
如果Available[j]=k,标是系统中现有j类资源k个。
2.最大需求矩阵Max,这是一个n×m的矩阵,它定义了系统中n个进程中的每一个进程对m类资源的最大需求。
如果Max[i][j]=k,表示进程i需要j类资源的最大数目为k。
3.分配矩阵Allocation,这是一个n×m的矩阵,它定义了系统中的每类资源当前分配到每一个进程的资源数。
如果Allocation[i][j]=k,表示进程i当前已经分到j类资源的数目为k个。
Allocation[i]表示进程i的分配向量。
4.需求矩阵Need,这是一个n×m的矩阵,用以表示每个进程还需要的各类资源的数目。
如果Need[i][j]=k,表示进程i还需要j类资源k个,才能完成其任务。
Need[i]表示进程i的需求向量。
上述三个矩阵间存在关系:Need[i][j]=Max[i][j]-Allocation[i][j];三、银行家算法Request是进程i的请求向量。
Request[j]=k表示进程i请求分配j类资源k个。
当进程i发出资源请求后,系统按下述步骤进行检查:1.如果Request ≤Need[i],则转向步骤2;否则,认为出错,因为它所请求的资源数已超过它当前的最大需求量。
2.如果Request ≤Available,则转向步骤3;否则,表示系统中尚无足够的资源满足进程i 的申请,进程i必须等待。
3.系统试探性地把资源分配给进程i,并修改下面数据结构中的数值:Available = Available - RequestAllocation[i]= Allocation[i]+ RequestNeed[i]= Need[i]- Request4.系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。
死锁实验报告
南华大学计算机科学与技术学院实验报告(2010 ~2011 学年度第二学期)课程名称计算机操作系统实验名称死锁的避免与检测姓名肖喜武学号20094350225专业软件工程班级本09软件02班地点8-212教师曹军日期2011-06-21一、实验内容(1)死锁的避免编写一个程序,实现银行家算法,当系统将资源分配给某一进程而不会死锁时,就分配之。
否则,推迟分配,并显示适当的信息。
(2)死锁的检测分别使用检测“进程—资源循环等待链”的方法和Coffman 的算法来检测进程的死锁状态。
对于相同的进程资源分配、占用次序,比较两个算法的结果。
二、实验目的通过本实验使学生进一步理解死锁的概念,并能选择一个算法来避免死锁,让学生进一步加深理解和掌握死锁的检测算法三、实验题目题目:死锁的避免和死锁的检测。
①数据结构struct Bank{int Available[m];//可利用资源向量int Max[m][n];//最大需求矩阵int Allocation[m][n];//分配矩阵int Need[m][n]; //需求矩阵};②程序总体框图四、源程序五、程序运行结果六、实验总结银行家算法是一个经典的避免死锁的算法,它可以有效的避免资源分配时产生死锁。
但死锁的避免时相当复杂的,而且浪费时间。
每次分配时都要进行分配检查看是否会产生死锁,通过实验加深对银行家算法的了解和认识,同时对避免死锁的机制也有所了解。
实验不仅锻炼了我动手能力,也巩固了我课堂所学的知识。
只有在实验过程中我们才能深刻的认识到课本知识的重要性。
实验采用银行家算法避免在资源分配时产生死锁现象。
死锁避免实验报告
“死锁避免”实验报告实验思路:先定义进程控制块的数据结构pcb,确定进程并发数目SIZE,在初始化进程时,保证各进程最大资源申请量不大于系统的资源总量,如果大于,则重新输入。
初始化完成之后,选择相应的死锁避免的算法,或随机分配算法,或银行家算法。
随机分配方法:运用取余的方法,轮询各个进程,选择处于就绪状态的进程之一,然后输入该进程的当前资源申请量apply,判断该申请量是否大于系统当前资源剩余量,若大于,将就绪进程状态设置为阻塞态,然后查找就绪队列中是否还有就绪进程,若有,则选择一个就绪进程,继续执行,若没有就绪进程,则表示发生死锁。
若不大于,则给满足该进程的申请量,并将其自愿申请量的变量设为0。
接着再进行判断该进程是否得到全部所需资源,若没有,则选择就绪队列中一个就绪进程,若全部得到,归还该进程所占有的全部资源给系统,并将该进程设置为完成态。
此时,再进行检查有无等待态的进程,若没有,则选择就绪队列中一个就绪进程,若有,则顺序检查等待进程,判断系统现有资源能满足某一等待进程,若能,则将该等待进程状态设置为就绪态,若没有,查找就绪队列中是否还有就绪进程,若有,则选择一个就绪进程,继续执行,若没有就绪进程,则表示发生死锁。
银行家算法:运用取余的方法,轮询各个进程,选择处于就绪状态的进程之一,然后输入该进程的当前资源申请量apply,判断该申请量是否大于系统当前资源剩余量,若大于,将就绪进程状态设置为阻塞态,然后查找就绪队列中是否还有就绪进程,若有,则选择一个就绪进程,继续执行,若没有就绪进程,则表示发生死锁。
若不大于,则假定满足该进程的申请量,并将其资源申请量的变量设为0,表示系统资源的变量减少相应的该进程的资源申请量,然后系统资源暂时用一个变量current保存起来。
将分配后系统剩余的资源数量与各进程的剩余需求量比较寻找一个系统能满足其需求的进程,每找一次,都要计数,用num变量,若找到,在标记数组a[SIZE]中进行相应标记,同时没找到一个都要进行一次对标记数组的循环测试,若测试到所有项都进行了标记,则退出循环,说明此次分配是安全的,若找不到,测试num的值,(对于确定数目的并发进程,其最大分配安全的循环次数<=SIZE!)。
死锁_银行家算法实验报告
实验目的银行家算法是避免死锁的一种重要方法。
通过编写一个模拟动态资源分配的银行家算法程序,进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念,并掌握避免死锁的具体实施方法二、实验要求根据银行家算法的基本思想,编写和调试一个实现动态资源分配的模拟程序,并能够有效地防止和避免死锁的发生。
(1)设计思想说明设计银行家算法是为了避免死锁三、实验方法内容1.算法设计思路银行家算法又称“资源分配拒绝”法,其基本思想是,系统中的所有进程放入进程集合,在安全状态下系统受到进程的请求后试探性的把资源分配给他,现在系统将剩下的资源和进程集合中其他进程还需要的资源数做比较,找出剩余资源能满足最大需求量的进程,从而保证进程运行完成后还回全部资源。
这时系统将该进程从进程集合中将其清除。
此时系统中的资源就更多了。
反复执行上面的步骤,最后检查进程的集合为空时就表明本次申请可行,系统处于安全状态,可以实施本次分配,否则,只要进程集合非空,系统便处于不安全状态,本次不能分配给他。
请进程等待2.算法流程图3.算法中用到的数据结构数据结构的说明1.可利用资源向量AVAILABLE。
这是一个含有M个元素的数组,其中的每一个元素代表一类可利用的资源数目,其3初始值是系统中所配置的该类全部可哦那个资源的数目,其数值随该类资源的分配和回收而动态的改变。
2.最大需求矩阵MAX。
这是一个M*N的矩阵,它定义了系统中N个进程中的每一个进程对M类资源的最大需求。
3.分配矩阵ALLOCATION。
这也是一个M*N的矩阵,它定义了系统中每一类资源当前已分配给每一进程的资源数。
4.需求矩阵NEED。
这也是一个M*N的矩阵,用以表示每一个进程尚需的各类资源数。
5.NEED[R,W]=MAX[R,W]-ALLOCATION[R,W]4.主要的常量变量#define W 10 //最大进程数W=10#define R 20 //最大资源总数R=20 int AVAILABLE[R]; //可利用资源向量int MAX[W][R]; //最大需求矩阵int ALLOCATION[W][R]; //分配矩阵int NEED[W][R]; //需求矩阵int Request[R]; //进程请求向量void changdata(int k);//进程请求资源数据改变int chksec(int s); //系统安全性的检测5.主要模块void inputdata()void showdata()void changdata(int k)void restoredata(int k) int chksec(int s)int chkmax(int s)四、实验代码#include<string.h>#include<iostream.h>#define FALSE 0#define TRUE 1#define W 10 //最大进程数W=10#define R 20 //最大资源总数R=20int M ;int N ;int ALL_RESOURCE[W];int AVAILABLE[R]; //可利用资源向量int MAX[W][R]; //最大需求矩阵int ALLOCATION[W][R]; //分配矩阵int NEED[W][R]; //需求矩阵int Request[R]; //进程请求向量void inputdata(); //数据输入void showdata(); //数据显示void changdata(int k);//进程请求资源数据改变void restoredata(int k); //数据恢复int chksec(int s); //系统安全性的检测int chkmax(int s); //检测最大需求void bank(); //检测分配的资源是否合理void main(){ int i,j;inputdata();for(i=0;i<M;i++){ j=chksec(i);if (j==0) break;}if (i>=M)cout<<"错误提示:经安全性检查发现,系统的初始状态不安全!!!\n"<<endl;else{ cout<<"提示:经安全性检查发现,系统的初始状态安全!"<<endl;bank();}}void inputdata(){ int i=0,j=0,p;cout<<"请输入总进程数:"<<endl;do{cin>>M;if (M>W) cout<<endl<<"总进程数超过了程序允许的最大进程数,请重新输入:"<<endl;}while (M>W);cout<<endl;cout<<"请输入资源的种类数:"<<endl;do {cin>>N;if (N>R)cout<<endl<<"资源的种类数超过了程序允许的最大资源种类数,请重新输入:"<<endl; }while (N>R);cout<<endl;cout<<"请依次输入各类资源的总数量,即设置向量all_resource:"<<endl;for(i=0;i<N;i++) cin>>ALL_RESOURCE[i];cout<<endl;cout<<"请依次输入各进程所需要的最大资源数量,即设置矩阵max:"<<endl;for (i=0;i<M;i++){for (j=0;j<N;j++){do { cin>>MAX[i][j];if (MAX[i][j]>ALL_RESOURCE[j])cout<<endl<<"该最大资源数量超过了声明的该资源总数,请重新输入:"<<endl; }while (MAX[i][j]>ALL_RESOURCE[j]);}}cout<<endl;cout<<"请依次输入各进程已经占据的各类资源数量,即设置矩阵allocation:"<<endl;for (i=0;i<M;i++){for (j=0;j<N;j++){do{ cin>>ALLOCATION[i][j];if (ALLOCATION[i][j]>MAX[i][j])cout<<endl<<"已占有的资源数量超过了声明的最大资源数量,请重新输入:"<<endl;}while (ALLOCATION[i][j]>MAX[i][j]);}}cout<<endl;for (i=0;i<M;i++)for(j=0;j<N;j++)NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];for (j=0;j<N;j++){ p=ALL_RESOURCE[j];for (i=0;i<M;i++){ p=p-ALLOCATION[i][j];AVAILABLE[j]=p;if(AVAILABLE[j]<0)AVAILABLE[j]=0;}}}void showdata(){ int i,j;cout<<"各种资源的总数量,即向量all_resource为:"<<endl;cout<<" ";for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<ALL_RESOURCE[j];cout<<endl<<endl;cout<<"当前系统中各类资源的可用数量,即向量available为:"<<endl; cout<<" ";for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<AVAILABLE[j];cout<<endl<<endl;cout<<"各进程还需要的资源数量,即矩阵need为:"<<endl<<endl;for (i=0;i<M;i++){ cout<<"进程P"<<i<<": ";for (j=0;j<N;j++)cout<<NEED[i][j]<<" ";cout<<endl;}cout<<endl;cout<<"各进程已经得到的资源量,即矩阵allocation为: "<<endl<<endl;for (i=0;i<M;i++){ cout<<"进程P"<<i<<": ";for (j=0;j<N;j++)cout<<ALLOCATION[i][j]<<" ";cout<<endl;} cout<<endl;}void changdata(int k){ int j;for (j=0;j<N;j++){AVAILABLE[j]=AVAILABLE[j]-Request[j];ALLOCATION[k][j]=ALLOCATION[k][j]+Request[j];NEED[k][j]=NEED[k][j]-Request[j];}}void restoredata(int k){int j;for (j=0;j<N;j++){ AVAILABLE[j]=AVAILABLE[j]+Request[j];ALLOCATION[k][j]=ALLOCATION[k][j]-Request[j];NEED[k][j]=NEED[k][j]+Request[j];}}int chksec(int s){int WORK,FINISH[W];int i,j,k=0;for(i=0;i<M;i++)FINISH[i]=FALSE;for(j=0;j<N;j++){ WORK=AVAILABLE[j];i=s;do{ if(FINISH[i]==FALSE&&NEED[i][j]<=WORK){WORK=WORK+ALLOCATION[i][j];FINISH[i]=TRUE;i=0;}else{ i++;}}while(i<M);for(i=0;i<M;i++)if(FINISH[i]==FALSE){ return 1;}} return 0;}int chkmax(int s){ int j,flag=0;for(j=0;j<N;j++){if (MAX[s][j]==ALLOCATION[s][j]){ flag=1;AVAILABLE[j]=AVAILABLE[j]+MAX[s][j];MAX[s][j]=0;}} return flag;}c{int i=0,j=0;char flag='Y';while(flag=='Y'||flag=='y'){i=-1;while(i<0||i>=M){ cout<<"请输入需申请资源的进程号(从P0到P"<<M-1<<",否则重新输入!):"; cout<<"p";cin>>i;if(i<0||i>=M)cout<<"输入的进程号不存在,重新输入!"<<endl;}cout<<"请输入进程P"<<i<<"申请的资源数:"<<endl;for (j=0;j<N;j++){ cout<<" 资源"<<j<<": ";cin>>Request[j];if(Request[j]>NEED[i][j]){ cout<<"进程P"<<i<<"申请的资源数大于进程P"<<i<<"还需要"<<j<<"类资源的资源量!";cout<<"申请不合理,出错!请重新选择!"<<endl<<endl;flag='N';break;}else{ if(Request[j]>AVAILABLE[j]){ cout<<"进程P"<<i<<"申请的资源数大于系统可用"<<j<<"类资源的资源量!";cout<<"申请不合理,出错!请重新选择!"<<endl<<endl;flag='N';break;}}}if(flag=='Y'||flag=='y'){ changdata(i);if(chksec(i)){ cout<<endl;cout<<"该分配会导致系统不安全!!! 本次资源申请不成功,不予分配!!!"<<endl;cout<<endl;restoredata(i);}else{ cout<<endl;cout<<"经安全性检查,系统安全,本次分配成功,且资源分配状况如下所示:"<<endl;cout<<endl;showdata();if(chkmax(i)){cout<<"在资源分配成功之后,由于该进程所需的某些资源的最大需求量已经满足,"<<endl;cout<<"因此在进程结束后系统将回收这些资源!"<<endl;cout<<"在资源收回之后,各进程的资源需求和分配情况如下所示:"<<endl;showdata();}}}cout<<endl;cout<<" 是否继续银行家算法演示,按'Y'或'y'键继续,按'N'或'n'键退出演示: ";cin>>flag; }}五、实验结果1.执行结果2.结果分析银行家算法就是当接收到一个系统资源的分配后找到一个安全序列,使得进程间不会发生死锁,若发生死锁则让进程等待。
操作系统死锁实验报告
程序结构如下:
当进程pi提出资源申请时,系统执行1)若Request[i]≤Need[i],转2);否则错误返回。2)若Request[i]≤Available,转3);否则进程等待。3)假设系统分配了资源,则有:
printf("%d",Need[i][j]); printf("\n");}share();}
分配成功分配失败
6.实验分析与体会
通过这次作业不仅使我对操作系统中银行家算法有了进一步的掌握,银行家算法是从当前状态出发,逐个按安全序列检查各客户中谁能完成其工作,然后假定其完成工作且归还全部贷款,再进而检查下一个能完成工作的客户。如果所有客户都能完成工作,则找到一个安全序列,银行家才是安全的。
与预防死锁的几种方法相比较,限制条件少,资源利用程度提高了。
由于要寻找一个安全序列,实际上增加了系统的开销。Banker algorithm最重要的一点是:保证操作系统的安全状态!这也是操作系统判断是否分配给一个进程资源的标准!
实验日期:2010年6月8日
教师评语
签名:年月日
2)若Finish[i]=False&&Need<=Work,则执行3);否则执行4)
3)进程P获得第i类资源,则顺利执行直至完成!并释放资源:
Work=Work+Allocation; Finish[i]=true;转2)
4) 若所有进程的Finish[i]=true,则表示系统安全;否则,不安全!
预防死锁和存储器管理实验报告
班级:学号:姓名:1、死锁避免算法的模拟实现一、实验目的通过本次实验,让同学们进一步了解死锁.对死锁有了认识以后,然后对系统安全和资源动态分配有了全新的的概念.学会编程实现银行家算法检验系统状态是否安全的方法.以便将来在实际中使用该方法打下基础。
二、实验环境Windows XP或者windows7环境下的VC++环境之下三、实验任务设系统中资源类集合为{A,B,C},资源类A中含有十个资源实例,资源类B中含有五个资源实例,资源类C中含有七个资源实例,又设系统中进程集合为{p0,p1,……,p4}。
在t0时刻系统状态如下:Maximum Allocation Need AvailableA B C A B C A B C AB CP0 7 5 3 0 1 0 7 4 3 3 3 2P1 3 2 2 2 0 0 1 2 2P2 9 0 2 3 0 2 6 0 0P3 2 2 2 2 1 1 0 1 1P4 4 3 3 0 0 2 4 3 11)判断此时系统是否处于安全状态;2)模拟某进程发出一个资源申请,作出决策,是否给该进程分配资源(如不造成死锁则分配,否则拒绝分配)。
3)修改程序,从数据文件中读取上述信息,并且可以适应具有不同资源类个数的系统,即不用修改程序就可处理含不同资源类个数系统。
1.提示1).安全状态介绍:说系统处于安全状态,如果系统中的所有进程能够按照某一种次序依次地进行完。
可形式化定义为:说系统处于安全状态,如果存在一个有系统中所有进程构成的安全进程序列<P1,P2,P3,……Pn>,一个进程序列是安全的,如果对于每一个进程Pi(1<=i<=n),它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj(j<i)当前占有资源量之和。
2).可采用避免死锁的银行家算法,为简化问题,现对该算法的思想及用到的数据结构描述如下:当一个新进程进入,它必须申明其资源需求最大量,即每个资源类各需多少资源实例。
死锁避免算法设计报告
漳州师范学院操作系统课程设计死锁避免算法设计姓名:学号:系别:专业:年级:指导教师:一、课程设计题目介绍(含设计目的)死锁避免算法设计是通过模拟实现银行家算法实现死锁避免目的:1、了解进程产生死锁的原因,了解为什么要进行死锁的避免。
2、掌握银行家算法的数据结构,了解算法的执行过程,加深对银行家算法的理解。
3、通过运用Dijkstra的银行家算法来避免多个进程运行中因争夺资源而造成僵局,即死锁要求:本课程设计可以实现教材3.6.3节中所描述的银行家避免死锁算法。
可自定义进程数目、资源类型和每种类型资源的数目;可输入每个进程对每种资源的最大需求、已经获得的数量;当某进程发起某种资源请求时,计算系统状态是否安全。
思想:操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。
当进程在执行中继续申请资源时,先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。
若超过则拒绝分配资源,若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量,若能满足则按当前的申请量分配资源,否则也要推迟分配,从而达到死锁的避免。
二、总体设计(含系统的结构、原理框图或模块介绍等)1.系统的结构2.原理框图从主函数开始进入银行家算法系统,先调用初始化函数chushihua()分别输入Allocation[i][j],Max[i][j],All[y]并判断是否符合条件,在调用函数show(),输出当前状态Available,Max[i][j],Allocation[i][j],Need[i][j]。
然后调用安全性算法函数safe()判断在该时刻是否处于安全状态,并输出安全序列。
然后调用银行家算法函数bank()进行试分配后再调用安全性算法函数判断在该时刻是否处于安全状态,若不安全,则恢复试分配时改变的值。
《死锁避免》实验报告
一、实验目的本次实验旨在通过模拟操作系统的资源分配和请求过程,深入理解死锁的概念、产生死锁的必要条件以及如何通过银行家算法来避免死锁的发生。
通过实验,学生能够掌握以下知识点:1. 死锁的概念及产生条件;2. 银行家算法的基本原理和实现方法;3. 资源分配和请求过程中的安全性检查;4. 通过银行家算法避免死锁的发生。
二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发工具:Visual Studio 20194. 实验环境:一台配置较高的计算机三、实验原理1. 死锁的概念死锁是指多个进程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,这些进程都将无法继续执行。
2. 产生死锁的必要条件产生死锁的必要条件有四个,分别为:(1)互斥条件:资源不能被多个进程同时使用;(2)持有和等待条件:进程已获得至少一个资源,但又提出了新的资源请求,而该资源已被其他进程占有,此时该进程会等待;(3)非抢占条件:已分配给进程的资源,在进程完成之前,不能被抢占;(4)循环等待条件:存在一种进程资源的循环等待链,即进程P1等待P2占有的资源,P2等待P3占有的资源,以此类推,最后Pn等待P1占有的资源。
3. 银行家算法银行家算法是一种避免死锁的算法,通过以下步骤实现:(1)初始化系统资源、进程最大需求、已分配资源等数据结构;(2)当进程请求资源时,判断是否满足以下条件:a. 当前可用资源数量大于等于进程请求的资源数量;b. 根据当前资源分配情况,系统处于安全状态;若满足以上条件,则分配资源;否则,进程等待。
(3)当进程释放资源时,更新可用资源数量和分配资源情况。
四、实验内容1. 设计系统资源、进程最大需求、已分配资源等数据结构;2. 实现银行家算法,包括资源分配、安全性检查等功能;3. 模拟进程请求资源和释放资源的过程,观察系统状态变化;4. 分析实验结果,验证银行家算法是否能够避免死锁的发生。
实验报告死锁
一、实验目的1. 理解死锁的概念和产生条件;2. 掌握死锁的避免、检测和解除方法;3. 通过实验加深对死锁处理策略的理解。
二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.73. 实验工具:Python内置模块三、实验原理死锁是指多个进程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,这些进程都将无法向前推进。
死锁的产生条件包括:互斥条件、占有和等待条件、非抢占条件、循环等待条件。
四、实验内容1. 死锁的产生与避免2. 死锁的检测与解除五、实验步骤1. 死锁的产生与避免(1)定义进程与资源首先,定义一个进程类,包含进程名、资源需求列表和资源分配列表。
资源类包含资源名和数量。
```pythonclass Process:def __init__(self, name, resource_list, allocation_list): = nameself.resource_list = resource_listself.allocation_list = allocation_listclass Resource:def __init__(self, name, count): = nameself.count = count```(2)创建进程与资源实例创建若干进程和资源实例,并初始化资源数量。
```pythonprocess_list = [Process('P1', ['R1', 'R2'], ['R1', 'R2']),Process('P2', ['R1', 'R2'], ['R1', 'R2']),Process('P3', ['R3', 'R4'], ['R3', 'R4'])]resource_list = [Resource('R1', 2), Resource('R2', 2), Resource('R3', 2), Resource('R4', 2)]```(3)实现死锁避免算法采用银行家算法,判断当前分配情况是否满足安全序列。
操作系统实验报告-利用银行家算法避免死锁
计算机操纵系统实验陈述之袁州冬雪创作题目操纵银行家算法防止死锁一、实验目标:1、加深懂得有关资源申请、防止死锁等概念,并体会和懂得死锁和防止死锁的详细实施方法.2、要求编写和调试一个系统动态分配资源的简单摹拟程序,观察死锁发生的条件,并采取银行家算法,有效的防止和防止死锁的发生.二、实验内容:用银行家算法实现资源分配:设计五个过程{p0,p1,p2,p3,p4}共享三类资源{A,B,C}的系统,例如,{A,B,C}的资源数量分别为10,5,7.过程可动态地申请资源和释放资源,系统按过程的申请动态地分配资源,要求程序具有显示和打印各过程的某一个时刻的资源分配表和平安序列;显示和打印各过程依次要求申请的资源号以及为某过程分配资源后的有关资源数据.三、问题分析与设计:1、算法思路:先对用户提出的请求停止合法性检查,即检查请求是否大于需要的,是否大于可操纵的.若请求合法,则停止预分配,对分配后的状态调用平安性算法停止检查.若平安,则分配;若不服安,则回绝申请,恢复到原来的状态,回绝申请.2、银行家算法步调:(1)如果Requesti<or =Need,则转向步调(2);否则,认为出错,因为它所需要的资源数已超出它所宣布的最大值.(2)如果Request<or=Available,则转向步调(3);否则,暗示系统中尚无足够的资源,过程必须等待.(3)系统试探把要求的资源分配给过程Pi,并修改下面数据布局中的数值:Available=Available-Request[i];Allocation=Allocation+Request;Need=Need-Request;(4)系统执行平安性算法,检查此次资源分配后,系统是否处于平安状态.3、平安性算法步调:(1)设置两个向量①工作向量Work.它暗示系统可提供过程继续运行所需要的各类资源数目,执行平安算法开端时,Work=Allocation;②布尔向量Finish.它暗示系统是否有足够的资源分配给过程,使之运行完成,开端时先做Finish[i]=false,当有足够资源分配给过程时,令Finish[i]=true.(2)从过程集合中找到一个能知足下述条件的过程:①Finish[i]=false②Need<or=Work如找到,执行步调(3);否则,执行步调(4).(3)当过程P获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故应执行:Work=Work+Allocation;Finish[i]=true;转向步调(2).(4)如果所有过程的Finish[i]=true,则暗示系统处于平安状态;否则,系统处于不服安状态.4、流程图:系统主要过程流程图银行家算法流程图平安性算法流程图5、主要数据布局假设有M个过程N类资源,则有如下数据布局:int max[M*N] M个过程对N类资源的最大需求量int available[N] 系统可用资源数int allocated[M*N] M个过程已经得到N类资源的资源量int need[M*N] M个过程还需要N类资源的资源量int worked[] 系统提供给过程继续运行所需的各类资源数目四、源代码import java.awt.*;import javax.swing.*;import java.util.*;import java.awt.event.*;import javax.swing.border.*;public class OsBanker extends JFrame { // 界面设计JLabel labelInfo;JLabel labelInfo1;int resourceNum, processNum;int count = 0;JButton buttonRequest, buttonSetInit, button, button1, buttonsearch,button2;JTextField tf1, tf2;JTextField[] textAvailable;JTextField[][] textAllocation;JTextField[][] textNeed;JTextField textProcessName;JTextField[] textRequest;int available[];int max[][];int need[][];int allocated[][];int SafeSequence[];int request[];boolean Finish[];int worked[];boolean flag = false;JFrame f1;JFrame f2;JFrame f3;JTextArea jt;void display() {Border border = BorderFactory.createLoweredBevelBorder();Border borderTitled = BorderFactory.createTitledBorder(border, "按钮区"); textAvailable = new JTextField[5];textAllocation = new JTextField[6][5];textNeed = new JTextField[6][5];textProcessName = new JTextField(""); textProcessName.setEnabled(false);textRequest = new JTextField[5];tf1 = new JTextField(20);tf2 = new JTextField(20);labelInfo = new JLabel("请先输入资源个数和过程个数(1~6),后单击确定");JPanel contentPane;contentPane = (JPanel) this.getContentPane(); contentPane.setLayout(null);contentPane.setBackground(Color.pink);labelInfo.setBounds(50, 10, 300, 40);labelInfo.setOpaque(true);labelInfo.setForeground(Color.red);labelInfo.setBackground(Color.pink);contentPane.add(labelInfo, null);JLabel b1 = new JLabel("资源个数:");b1.setForeground(Color.blue);JLabel b2 = new JLabel("过程个数:");b2.setForeground(Color.blue);b1.setBounds(50, 80, 80, 30);contentPane.add(b1, null);tf1.setBounds(180, 80, 170, 30);contentPane.add(tf1, null);b2.setBounds(50, 150, 80, 30);contentPane.add(b2, null);tf2.setBounds(180, 150, 170, 30);contentPane.add(tf2, null);button1 = new JButton("确定");button = new JButton("重置");button1.setBounds(80, 200, 80, 30);contentPane.add(button1, null);button.setBounds(220, 200, 80, 30);contentPane.add(button, null);this.setSize(400, 300);this.setResizable(false);this.setTitle("银行家算法(SXJ)");this.setLocationRelativeTo(null);this.setDefaultClo搜索引擎优化peration(EXIT_ON_CLOSE);this.setVisible(true);f1 = new JFrame();labelInfo1 = new JLabel("请先输入最大需求和分配矩阵,然后单击初始化");JPanel contentPane1;contentPane1 = (JPanel) f1.getContentPane(); contentPane1.setLayout(null);contentPane1.setBackground(Color.pink);labelInfo1.setOpaque(true);labelInfo1.setBounds(75, 10, 400, 40);labelInfo1.setBackground(Color.pink);labelInfo1.setForeground(Color.blue);contentPane1.add(labelInfo1, null);JLabel labelAvailableLabel = new JLabel("AllResource:");JLabel labelNeedLabel = new JLabel("MaxNeed:"); JLabel labelAllocationLabel = new JLabel("allocated:");JLabel labelRequestLabel = new JLabel("request process:");labelNeedLabel.setBounds(75, 90, 100, 20);// x,y,width,heightcontentPane1.add(labelNeedLabel, null); labelAllocationLabel.setBounds(75, 240, 100, 20); contentPane1.add(labelAllocationLabel, null); labelAvailableLabel.setBounds(75, 70, 100, 20); contentPane1.add(labelAvailableLabel, null); labelRequestLabel.setBounds(75, 400, 100, 20); contentPane1.add(labelRequestLabel, null);JLabel[] labelProcessLabel1 = { new JLabel("过程1"), new JLabel("过程2"),new JLabel("过程3"), new JLabel("过程4"), new JLabel("过程5"),new JLabel("过程6") };JLabel[] labelProcessLabel2 = { new JLabel("过程1"), new JLabel("过程2"),new JLabel("过程3"), new JLabel("过程4"), new JLabel("过程5"),new JLabel("过程6") };JPanel pPanel1 = new JPanel(), pPanel2 = new JPanel(), pPanel3 = new JPanel(), pPanel4 = new JPanel();pPanel1.setLayout(null);pPanel2.setLayout(null);/** pPanel4.setLayout(null); pPanel4.setBounds(440,120,90,270);* pPanel4.setBorder(borderTitled);*/buttonSetInit = new JButton("初始化");buttonsearch = new JButton("检测平安性");button2 = new JButton("重置");buttonRequest = new JButton("请求资源"); buttonSetInit.setBounds(420, 140, 100, 30); contentPane1.add(buttonSetInit, null);buttonsearch.setBounds(420, 240, 100, 30); contentPane1.add(buttonsearch, null);button2.setBounds(420, 340, 100, 30);contentPane1.add(button2, null);buttonRequest.setBounds(420, 425, 100, 30); contentPane1.add(buttonRequest, null);for (int pi = 0; pi < 6; pi++) {labelProcessLabel1[pi].setBounds(0, 0 + pi * 20, 60, 20);labelProcessLabel2[pi].setBounds(0, 0 + pi * 20, 60, 20);}pPanel1.setBounds(75, 120, 60, 120);pPanel2.setBounds(75, 270, 60, 120);for (int pi = 0; pi < 6; pi++) {pPanel1.add(labelProcessLabel1[pi], null);pPanel2.add(labelProcessLabel2[pi], null);}contentPane1.add(pPanel1);contentPane1.add(pPanel2);contentPane1.add(pPanel4);for (int si = 0; si < 5; si++)for (int pi = 0; pi < 6; pi++) {textNeed[pi][si] = new JTextField();textNeed[pi][si].setBounds(150 + si * 50, 120 + pi * 20, 50, 20); textNeed[pi][si].setEditable(false);textAllocation[pi][si] = new JTextField(); textAllocation[pi][si].setBounds(150 + si * 50, 270 + pi * 20,50, 20);textAllocation[pi][si].setEditable(false);}for (int si = 0; si < 5; si++) {textAvailable[si] = new JTextField();textAvailable[si].setEditable(false);textAvailable[si].setBounds(150 + si * 50, 70, 50, 20);textRequest[si] = new JTextField();textRequest[si].setEditable(false);textRequest[si].setBounds(150 + si * 50, 430, 50, 20);contentPane1.add(textAvailable[si], null); contentPane1.add(textRequest[si], null);}for (int pi = 0; pi < 6; pi++)for (int si = 0; si < 5; si++) {contentPane1.add(textNeed[pi][si], null); contentPane1.add(textAllocation[pi][si], null);}textProcessName.setBounds(80, 430, 50, 20); contentPane1.add(textProcessName, null);f1.setSize(550, 500);f1.setResizable(false);f1.setTitle("银行家算法(SXJ)");f1.setLocationRelativeTo(null);f1.setDefaultClo搜索引擎优化peration(EXIT_ON_CLOSE);// f1.setVisible(true);f1.setVisible(false);f2 = new JFrame("平安序列显示框");jt = new JTextArea(75, 40);jt.setBackground(Color.pink);jt.setForeground(Color.blue);JScrollPane scrollPane = new JScrollPane(jt); // 加滚动条scrollPane.setBorder(BorderFactory.createLoweredBev elBorder());// 鸿沟(f2.getContentPane()).add(scrollPane);f2.setSize(450, 400);f2.setResizable(false);f2.setDefaultClo搜索引擎优化peration(EXIT_ON_CLOSE);f2.setVisible(false);buttonSetInit.setEnabled(false);buttonRequest.setEnabled(false);buttonsearch.setEnabled(false);button1.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) {// labelInfo.setText("请先初始化allocated和Maxneed,后单击初始化按钮");f1.setVisible(true);buttonSetInit.setEnabled(true);resourceNum = Integer.parseInt(tf1.getText());processNum = Integer.parseInt(tf2.getText());for (int i = 0; i < processNum; i++) {for (int j = 0; j < resourceNum; j++) {textNeed[i][j].setEditable(true);textAllocation[i][j].setEditable(true);textAvailable[j].setEditable(true);}}}});buttonSetInit.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {Init();buttonsearch.setEnabled(true);}});buttonsearch.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {count = 0;SafeSequence = new int[processNum];worked = new int[resourceNum];Finish = new boolean[processNum];copyVector(worked, available);Safety(0);jt.append("平安序列数量:" + count);if (flag) {labelInfo1.setText("当前系统状态:平安");f2.setVisible(true);buttonRequest.setEnabled(true);textProcessName.setEnabled(true);for (int i = 0; i < resourceNum; i++) {textRequest[i].setEditable(true);}} else {labelInfo1.setText("当前系统状态:不服安");}buttonSetInit.setEnabled(false);}});buttonRequest.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {count = 0;for (int i = 0; i < processNum; i++) {Finish[i] = false;}jt.setText("");flag = false;RequestResource();}});button2.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) {/** tf1.setText(""); tf2.setText("");*/f2.setVisible(false);jt.setText("");for (int i = 0; i < processNum; i++) {for (int j = 0; j < resourceNum; j++) { textNeed[i][j].setText("");textAllocation[i][j].setText("");textAvailable[j].setText("");textRequest[j].setText("");// textNeed[i][j].setEditable(false);// textAllocation[i][j].setEditable(false);// textAvailable[j].setEditable(false);textRequest[j].setEditable(false); textProcessName.setText("");Finish[i] = false;}}flag = false;buttonsearch.setEnabled(false);// labelInfo.setText("请先输入资源个数和过程个数,后单击确定");}});button.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) {tf1.setText("");tf2.setText("");f2.setVisible(false);jt.setText("");flag = false;}});}void copyVector(int[] v1, int[] v2) { for (int i = 0; i < v1.length; i++)v1[i] = v2[i];}void Add(int[] v1, int[] v2) {for (int i = 0; i < v1.length; i++)v1[i] += v2[i];}void Sub(int[] v1, int[] v2) {for (int i = 0; i < v1.length; i++) v1[i] -= v2[i];}boolean Smaller(int[] v1, int[] v2) { boolean value = true;for (int i = 0; i < v1.length; i++)if (v1[i] > v2[i]) {value = false;break;}return value;}public static void main(String[] args) {OsBanker ob = new OsBanker();ob.display();// System.out.println(" "+count);}void Init() // 初始化操纵矩阵{available = new int[resourceNum];for (int i = 0; i < resourceNum; i++) {available[i] = Integer.parseInt(textAvailable[i].getText());}max = new int[processNum][resourceNum];allocated = new int[processNum][resourceNum];need = new int[processNum][resourceNum];for (int i = 0; i < processNum; i++) {for (int j = 0; j < resourceNum; j++) {max[i][j] = Integer.parseInt(textNeed[i][j].getText());allocated[i][j] = Integer.parseInt(textAllocation[i][j].getText());}}for (int i = 0; i < resourceNum; i++)for (int j = 0; j < processNum; j++)need[j][i] = max[j][i] - allocated[j][i];for (int i = 0; i < resourceNum; i++)for (int j = 0; j < processNum; j++) {available[i] -= allocated[j][i];if (available[i] < 0) {labelInfo.setText("您输入的数占有误,请重新输入"); }}}void Safety(int n) // 查找所有平安序列{if (n == processNum) {count++;for (int i = 0; i < processNum; i++) {jt.append("过程" + (SafeSequence[i] + 1) + " "); }jt.append("\n");flag = true;return;}for (int i = 0; i < processNum; i++) { if (Finish[i] == false) {boolean OK = true;for (int j = 0; j < resourceNum; j++) { if (need[i][j] > worked[j]) {OK = false;break;}}if (OK) {for (int j = 0; j < resourceNum; j++) { worked[j] += allocated[i][j];}Finish[i] = true;SafeSequence[n] = i;Safety(n + 1);Finish[i] = false;SafeSequence[n] = -1;// num++;for (int j = 0; j < resourceNum; j++) {worked[j] -= allocated[i][j];}}}}}void RequestResource() { // 请求资源jt.setText("");int processname = (Integer.parseInt(textProcessName.getText()) - 1); request = new int[resourceNum];for (int i = 0; i < resourceNum; i++) {request[i] = Integer.parseInt(textRequest[i].getText());}if (!Smaller(request, need[processname])) { labelInfo.setText("资源请求不符该过程的需求量.");} else if (!Smaller(request, available)) {labelInfo1.setText("可用资源缺乏以知足请求,过程需要等待.");} else {Sub(available, request);Add(allocated[processname], request);Sub(need[processname], request);copyVector(worked, available);Safety(0);if (flag) {labelInfo1.setText("可当即分配给该过程!");} else {labelInfo1.setText("分配后导致系统处于不服安状态!,不成当即分配");Add(available, request);Sub(allocated[processname], request);Add(need[processname], request);}}// }}}五、实验成果:初始界面:初始化:检测平安性:请求资源:(1)过程2(1,0,2)(2)过程5(3,3,0)(3)过程1(0,2,0)六、遇到的问题及缺乏之处:1、程序编写的时候规定最大资源数和最大过程数均<=6.2、程序直接初始化了6个过程框,既华侈了内存空间,又对可视化界面的雅观造成影响.3、未对输入异常停止处理:比方在请求资源的第一个方框中只能填入过程的数字编号,当填入的为非整数时,程序会抛出异常.4、未处理过程名中对字符串的处理,直接固定过程名为数字,用户不克不及直接输入原有的过程名,造成欠好的用户体验.。
采用银行家算法避免死锁
采用银行家算法避免死锁一、实验目的:观察死锁发生的现象,了解死锁发生的原因。
掌握如何判断死锁发生的方法。
二、实验分析:死锁现象是操作系统各个进程竞争系统中有限的资源引起的。
如果随机给进程分配资源,就可能发生死锁,因此就应有办法检测死锁的发生。
本次实验中采用“银行家算法”判断死锁的发生。
三、实验设计:本实验设计一个3个并发进程共享3种系统资源且每种系统资源有10个的系统。
系统能显示各种进程的进展情况以及检察是否有错误和死锁现象产生。
四、算法说明:“银行家算法”。
按每个进程的申请数量给各个进程试探性分配资源,看能否找到一个序列使各个进程都能正常运行结束。
若能,则不会发生死锁;若不能,则会发生死锁。
五、程序使用说明:1、本程序用于检测错误和是否会发生死锁。
系统有3个进程竞争3种系统资源,每种资源有10个。
2、输入各个进程的最大需求资源数目数组max[3]和已经得到的资源数目数组alloc [3],系统计算出各个进程还应申请的资源数目数组need[3]。
3、若进程最大需求数大于系统资源数(10),则出错;若进程申请的资源数目大于其需要的最大资源数目,则出错。
银行家算法的具体实现程序:#include <stdio.h>#define R 10#define P 10int SafeCheck(int n,int m,int Max[P][R],int Allocation[P][R],int Available[R],int Need[P][R]){int p,i,j, safeque[P],Work[R],Finish[P]={0},t=0,flag;printf("当前的工作向量为:");for(j=0;j<m;j++){Work[j]=Available[j];printf("%d,",Work[j]);}//设置Work向量while(t<n){//开始寻找可分配的进程for(i=0;i<n;i++){if(Finish[i]==1) flag=0;//跳过已分配结束的进程else flag=1;if(flag){p=i;for(j=0;j<m;j++)if(Need[p][j]>Work[j]) { p=-1; break; }}if(p==i){ printf("找到一个可分配的进程P%d!\n",p); break;} }//顺序循环查找可分配资源的进程if(p!=-1){safeque[t++]=p;//入栈保护Finish[p]=1;//标志该进程结束printf("当前的工作向量为:");for(j=0;j<m;j++){Work[j]+=Allocation[p][j];printf("%d,",Work[j]);}p=-1;//清空当前进程号,以便下一次寻找出新的进程}//找到可分配资源的进程,并重设Work向量else { printf("找不到一个可分配的进程!终止检查!"); break; } }if(t==n){printf("系统存在一个安全序列:");for(t=0;t<n;t++)printf("P%d->",safeque[t]);printf("\n");return 1;}else {printf("系统不安全!会产生死锁!\n"); return 0;}}void main(){int Available[R],Max[P][R],Allocation[P][R],Need[P][R];int i,n,m,j,p,Request[R];int safe1,safe2;//设置第一次检查与第二次检查正确与否的观察变量printf("输入进程总数:");scanf("%d",&n);printf("输入资源类数:");scanf("%d",&m);printf("系统中R0--R%d类资源可利用数(空格隔开):",m-1);for(i=0;i<m;i++){scanf("%d",&Available[i]);}for(i=0;i<n;i++){printf("P%d进程的每类资源的分配情况如下:\n",i);printf("\tR0--R%d类资源最大数(空格隔开):",m-1);for(j=0;j<m;j++){scanf("%d",&Max[i][j]);}printf("\tR0--R%d类资源已分配(空格隔开):",m-1);for(j=0;j<m;j++){scanf("%d",&Allocation[i][j]);Need[i][j]=Max[i][j]-Allocation[i][j];}printf("\tR0--R%d类资源需求数(空格隔开):",m-1);for(j=0;j<m;j++){printf("%d ",Need[i][j]);}printf("\n");}//初始化进程的资源分配表printf("——————-第一次安全性检查——————\n");safe1=SafeCheck(n,m,Max,Allocation,Available,Need);if(safe1){printf("输入请求请求进程P的进程号:");scanf("%d",&p);printf("输入请求的R0--R%d各类资源数(空格隔开):",m-1);for(j=0;j<m;j++){scanf("%d",&Request[j]);if(Request[j]>Need[p][j]){printf("所请求的该资源数大于该进程所需求的最大值!终止请求!");safe1=0;break;}if(Request[j]>Available[j]){printf("所请求的该资源数大于系统中所拥有的最大值!终止请求!");safe1=0;break;}}}//第一次安全检查系统安全后判断请求向量的正确性if(safe1){printf("——————-第二次安全性检查——————\n");for(j=0;j<m;j++){Allocation[p][j]+=Request[j];Need[p][j]=Max[p][j]-Allocation[p][j];Available[j]-=Request[j];}//第二次安全检查前试探分配资源给请求资源safe2=SafeCheck(n,m,Max,Allocation,Available,Need);if(safe2==0)for(j=0;j<m;j++){Allocation[p][j]-=Request[j];Need[p][j]=Max[p][j]-Allocation[p][j];Available[j]+=Request[j];}//安全检查失败后重新收回分配给请求进程的资源}}书上的银行家算法例题实现如下:分析:该程序找到的安全序列:第一次检查{p1,p3,p0,p2,p4}第二次检查{p1,p3,p0,p2,p4}虽然与书上例题不一致,但经检验可以找出如上安全序列。
2.操作系统试验--死锁的避免——银行家算法
操作系统实验二死锁的避免——银行家算法一、实验目的银行家算法是避免死锁的一种重要算法,本实验要求用高级语言编写和调试一个简单的银行家算法程序。
加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。
二、实验要求:编制程序, 依据银行家算法判定本次分配是否安全。
三.算法所用數據結構讲解1.数据结构假设有m个进程N类资源,则有如下数据结构MAX[M*N] M个进程对N 类资源的最大需求量;A V AILABEL[N] 系统可用资源数;ALLOCATION[M*N] M个进程已得到N 类资源的资源量;NEED[M*N] M个进程还需要N 类资源的资源量;2.行家算法设进程I 提出请求Request[N],则(1)若Request[N]<= NEED[I,N],则转(2);否则出错。
(2)若NEED[I,N] <= A V AILABEL[N],则转3;否则出错。
3.安全性检查(1)从进程集合中找到一个能满足下述条件的进程:①Finish[i]=false; ②Needi≤Work.如找到,执行步骤(2);否则执行步骤(3)。
(2)当进程Pi获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故执行:Work:=Work+Allocation; Finish[i]:=true; Goto step1;(3)如果所有进程的Finish[i]=true,则表示系统处于安全状态;否则,系统处于不安全状态。
四.实验报告要求1.写出实验目的2。
写出实验要求3。
写出实验内容(包括算法,程序流程图及部分实验结果)4.实验总结与体会附:#include "stdio.h"#define M 5 /*总进程数*/#define N 3 /*总资源数*/#define FALSE 0#define TRUE 1/*M个进程对N类资源最大资源需求量*/int MAX[M][N]= {{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};/*系统可用资源数*/int A V AILABLE[N]={3,3,2};/* M个进程已经得到N类资源的资源量*/int ALLOCATION[M][N]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};/* M个进程还需要N类资源的资源量*/int NEED[M][N]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};int Request[N]={0,0,0};int i=0,j=0;void main(){char flag='Y';void showdata();void changdata(int);void rstordata(int);int chkerr(int);showdata();while (flag=='Y'||flag=='y'){printf("输入申请资源的进程号(0~4):");scanf("%d",&i);while (i<0||i>=M){printf("输入的进程号不存在,请重输入申请资源的进程号(0~4):");scanf("%d",&i);}for(j=0;j<N;j++){printf("申请资源%d :",j);scanf("%d",&Request[j]);if (Request[j]>NEED[i][j]){printf("进程%d申请的资源数大于进程%d还需要%d类资源的资源量!",i,i,j);printf("申请不合理,出错!请重新选择\n");exit(0);}else{if (Request[j]>A V AILABLE[j]){printf("进程%d 申请的资源数大于系统可用%d类资源的资源量!",i,j);printf("本次分配不成功。
死锁的避免
任务五、死锁的避免一、实验目的在多道程序系统中,多个进程的并发执行来改善系统的资源利用率,提高系统的吞吐量,但可能发生一种危险——死锁。
所谓死锁(Deadlock),是指多个进程在运行过程中因争夺资源而造成的一种僵局(DeadlyEmbrace),当进程处于这种状态时,若无外力作用,他们都无法在向前推进。
我们可以在分配资源时加上限制条件就可以预防死锁,但是,在每一种预防死锁的方法之中,都施加了较强的限制条件;而在避免死锁的方法中,所施加的限制条件较弱,有可能获得令人满意的系统性能。
二、实验内容利用银行家算法来避免死锁的发生三、实验代码#include<stdio.h>#define N 5 //进程个数#define M 3 //资源种类数void print();int check_safe();int check_distribution(int* p,int k);char processnema[N]; //进程名int Request[M]; //请求向量int Finish[N]; //标记某一个进程是否可以执行int Work[N][M]; //初始为Available[][],随寻找安全序列而变化,防止安全序列未找到而丢了初始状态的值int Available[M]; //资源清单--系统中现有各资源空闲个数int Work_Allocation[N][M];int Max[N][M]; //最大需求矩阵--每个进程对各类资源的最大需求数int Allocation[N][M];//分配矩阵--系统给每个进程已分配的各类资源数int Need[N][M]; //需求矩阵--每个进程还需要每种资源的个数int sequence[N]={0};//存放安全序列号void main(){int i=0,j=0,k=0;//记录申请资源的进程的序列号int flag=0; //标记输入的进程名是否存在int safe=0; //标志系统是否出于安全状态,0表示不安全,1表示安全int distribution=0; //标志是否可以进行试分配0表示可以,1表示不可以char flag1; //标记是否有进程申请资源//Need[N][M]=Max[N][M]-Allocation[N][M];char name; //要请求资源的进程名printf("~~~~~~~~~~~银行家算法~~~~~~~~~~~~~\n");printf(" 请分别初始化各矩阵信息 \n");printf("*请输入各进程的进程名\n"); //进程名连续输入for(i=0; i<N; i++){scanf("%c",&processnema[i]);}printf("请输入现有各资源空闲个数\n");for(i=0; i<M; i++){scanf("%d",&Available[i]);}printf("请分别输入每个进程对各类资源的最大需求数\n");for(i=0; i<N; i++){for(j=0; j<M; j++){scanf("%d",&Max[i][j]);}}printf("请分别输入系统给每个进程已分配的各类资源数\n");for(i=0; i<N; i++){for(j=0; j<M; j++){scanf("%d",&Allocation[i][j]);}}//printf("请分别输入每个进程还需要每种资源的个数\n");for(i=0; i<N; i++){for(j=0; j<M; j++){Need[i][j]=Max[i][j]-Allocation[i][j];}}printf("信息输入完毕\n");for(i=0; i<N; i++){sequence[i]=i;}print();safe=check_safe(); //检查初始状态是否安全if(0 == safe){printf("系统现处于不安状态,不能为进程分配资源,进入死锁状态。
死锁避免实验报告
沈阳工程学院学生实验报告(课程名称:操作系统)一、实验题目死锁避免实验。
二、实验要求编写一段程序模拟银行家算法。
三、实验目的多个进程动态地共享系统的资源时可能会产生死锁现象。
银行家算法是通过对资源的分配进行动态地检查来达到避免死锁的目的。
本实验通过模拟银行家算法的应用,使读者了解银行家算法的执行过程。
从而进一步理解死锁产生的条件和避免死锁问题产生的方法。
四、实验原理分析⑴死锁的产生必须同时满足4个条件:●互斥条件,即一个资源每次只能由一个进程占用。
●请求与保持条件,即一进程请求资源不能满足时,它必须等待,同时它仍保持已得到的所有其它资源。
●不可剥夺条件,任何一个进程不能抢占另一个进程已经获得且未释放的资源。
●环路等待条件,系统进入死锁的状态时,进程和资源之间形成一个封闭的环路。
⑵银行家算法是一种具有代表性的避免死锁的算法。
银行家算法为资源分配定义了两种状态,安全状态和不安全状态。
●安全状态:如果存在一个由系统中所有进程构成的安全序列P1,…,Pn,则系统处于安全状态。
处于安全状态的系统一定没有死锁发生。
●不安全状态:当系统中不存在一个安全序列时系统处于不安全状态。
不安全状态下一定导致死锁发生。
五、实验过程记录1.流程图安全算法流程图银行家算法2.实验结果图1图2图3图43.结果分析1.对于图1来说因为P0 申请的资源大于他所需求的,所以认为此次分配出错2.对于图2来说因为P0申请的资源大于剩余的资源,所以此次分配出错3对于图3来说对于系统安全且能分配序列的t0安全时刻表资源情况进程max Need allocation Work+allocationfinishQ W QWQ W Q WP0 4 5 1 2 3 3 4 11 true P1 3 6 1 2 2 4 6 15 true P2 5 7 1 2 4 5 10 20 trueP0申请资源是的安全性检查资源情况进程work need allocation Work+allocation finish Q W Q W Q W Q WP0 0 7 0 1 4 4 4 11 truep1 4 11 1 2 2 4 6 15 True P2 6 15 1 2 4 5 10 20 TRUE4.对于图4来说因为最大需求大于可利用资源所以系统不安全五、成绩评定优良中及格不及格出勤内容格式分析总评指导教师:年月日源代码#include <iostream>using namespace std;#define False 0#define True 1int Max[100][100]={0};int Allocation[100][100]={0};int Need[100][100]={0};int Available[100]={0};int Work[100]={0};char name[100]={0};int temp[100]={0};int S=100,P=100;int safequeue[100]={0};int Request[100]={0};//void Showdata(){int i,j,k,l;cout<<"\t资源分配情况\n"<<endl;cout<<"\tMax"<<"\t已分配"<<"\tNeed"<<endl;cout<<"\t";for(j=0;j<3;j++){for (i=0;i<S;i++){cout<<name[i]<<" ";}cout<<"\t";}cout<<endl;for(i=0;i<P;i++){cout<<i<<"\t";for (j=0;j<S;j++){cout<<Max[i][j]<<" ";}cout<<"\t";for (k=0;k<S;k++){cout<<Allocation[i][k]<<" ";}cout<<"\t";for (l=0;l<S;l++){cout<<Need[i][l]<<" ";}cout<<endl;}cout<<"\nAvailable"<<endl;for (i=0;i<S;i++){cout<<name[i]<<" ";}cout<<endl;for (i=0;i<S;i++){cout<<Available[i]<<" ";}cout<<endl;}int Judgesafe(){int tempwork[100][100]={0};int i,x,k=0,m,apply,Finish[100]={0};int j;int flag=0;for (i=0;i<S;i++){Work[i]=Available[i];}for(i=0;i<P;i++){apply=0;for(j=0;j<S;j++){if (Finish[i]==False&&Need[i][j]<=Work[j]){apply++;if(apply==S){for(m=0;m<S;m++){tempwork[i][m]=Work[m];Work[m]=Work[m]+Allocation[i][m];}Finish[i]=True;temp[k]=i;i=-1;k++;flag++;}}}}for(i=0;i<P;i++)if(Finish[i]==False){cout<<"系统不安全"<<endl;return -1;}}cout<<"系统是安全的"<<endl;cout<<"分配的序列:";for(i=0;i<P;i++){cout<<temp[i];if(i<P-1) cout<<"->";}cout<<endl;return 0;}void Changedata(int flag){for (int i=0;i<S;i++){Available[i]=Available[i]-Request[i];Allocation[flag][i]=Allocation[flag][i]+Request[i];Need[flag][i]=Need[flag][i]-Request[i];}//void Share(){int i,flag;char ch='Y';cout<<"输入请求资源的进程:"<<endl;cin>>flag;if (flag>=P){cout<<"此进程不存在!"<<endl;}else{cout<<"输入此进程对各个资源的请求数量:"<<endl;for (i=0;i<S;i++){cin>>Request[i];}for (i=0;i<S;i++){if (Request[i]>Need[flag][i]){cout<<"进程"<<flag<<"申请的资源大于它所需要的资源!"<<endl;cout<<"分配不合理不予分配!"<<endl;ch='N';break;}else if (Request[i]>Available[i]){cout<<"进程"<<flag<<"申请的资源大于可利用的资源。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
信息科学与技术学院实验报告课程名称: 操作系统实验项目: 死锁的避免实验地点:指导教师: 日期:实验类型:(验证性实验综合性实验设计性实验)专业: 计算机服务外包班级: 14外3 姓名: 周鹏飞学号: 1414104033一、实验目的及要求了解死锁避免的概念,掌握避免死锁的算法二、实验仪器、设备或软件VC++6.0三、实验内容及原理银行家算法流程图:银行家算法是死锁处理中较为经典的一种避免死锁的方法,它一般分为单资源银行家算法和多资源银行家算法,所谓单资源银行家算法是指只有一种可用资源,多银行家算法是指由多种可用资源,它主要是通过合理的分配资源使得系统不产生死锁的思想来完成。
1.Available是一个长度为m的向量,它表示每类资源可用的数量,Available【j】=k表示rj类资源可用的数量为k。
2.Max是一个n*m矩阵,它表示每个进程对资源的最大需求,Max【i,j】=k,表示进程之多可用申请k个rj类资源单位。
3,Allocation是一个n*m矩阵,它表示当前分给每个进程的资源数目。
Allocation【i,j】=k,表示进程当前分到k个rj类资源。
4.Need是一个n*m矩阵,它表示每个进程还缺少多少资源。
Need【i,j】=k,表示进程尚需k个rj类资源才能完成其任务。
显然Need【i,j】=Max【i,j】-Allocation【i,j】。
当输入进程数与资源数,以及各进程所需的资源和已分配资源之后,系统就会寻找安全序列,若能找到一个安全序列,则结果表明当前系统安全,若找不到则当前系统不安全。
假设进程P提出请求Request[i],则银行家算法按如下步骤进行判断:1)如果Request[i] <=Need[i],则转向2);否则出错。
2)如果Request[i] <=Available[i],则转向3);否则出错。
3)系统试探分配相关资源,修改相关数据:Available[i]=Available[i]-Request[i];Allocation[i]=Allocation[i]+Request[i];Need[i]=Need[i]-Request[i];4)系统执行安全性检查,如安全,则分配成立;否则试探性分配资源作废,系统恢复原状,进程进入等待状态。
4.1.2安全检测函数(check)1)设置两个向量work和finish:work = available,表示系统可提供给进程继续运行所需的各类资源数目;finish表示系统是否有足够的资源分配给进程,使之完成。
开始时先做finish【i】:=false;当有足够资源分配给进程时,再令finish【i】:=true。
2)从进程集合中找到一个嫩满足下述条件的进程:a:finish【i】=false;b:need【i】【j】<=work[j];若找到,执行(3),否则,执行(4)。
3):当进程i获得资源后,可顺利执行,直到完成,并释放出分配给它的资源,故应执行:Work【j】:=work【j】+allocation[i,j];Finish[i]:=true;A[v++]=I;Go to step 2;4):如果所有进程的finish【i】=true都满足,则表示系统处于安全状态,输出安全序列,否则系统处于不安全状态。
四、实验步骤(或过程)#include<iostream.h>#include<string.h>#include<stdio.h>#define False 0#define True 1int 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;//资源的最大数为100void showdata()//显示资源矩阵{int i,j;cout<<"系统目前可用的资源[Avaliable]:"<<endl;for(i=0;i<N;i++)cout<<name[i]<<" ";cout<<endl;for (j=0;j<N;j++)cout<<Avaliable[j]<<" ";//输出分配资源cout<<endl;cout<<" Max Allocation Need"<<endl;cout<<"进程名 ";for(j=0;j<3;j++){for(i=0;i<N;i++)cout<<name[i]<<" ";cout<<" ";}cout<<endl;for(i=0;i<M;i++){cout<<" "<<i<<" ";for(j=0;j<N;j++)cout<<Max[i][j]<<" ";cout<<" ";for(j=0;j<N;j++)cout<<Allocation[i][j]<<" ";cout<<" ";for(j=0;j<N;j++)cout<<Need[i][j]<<" ";cout<<endl;}}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,k=0,m,apply,Finish[100]={0};int j;int flag=0;Work[0]=Avaliable[0];Work[1]=Avaliable[1];Work[2]=Avaliable[2];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){for(m=0;m<N;m++)Work[m]=Work[m]+Allocation[i][m];//变分配数Finish[i]=True;temp[k]=i;i=-1;k++;flag++;}}}}for(i=0;i<M;i++){if(Finish[i]==False){cout<<"系统不安全"<<endl;//不成功系统不安全return -1;}}cout<<"系统是安全的!"<<endl;//如果安全,输出成功cout<<"分配的序列:";for(i=0;i<M;i++){//输出运行进程数组cout<<temp[i];if(i<M-1) cout<<"->";}cout<<endl;return 0;}void share()//利用银行家算法对申请资源对进行判定{char ch;int i=0,j=0;ch='y';cout<<"请输入要求分配的资源进程号(0-"<<M-1<<"):";cin>>i;//输入须申请的资源号cout<<"请输入进程 "<<i<<" 申请的资源:"<<endl;for(j=0;j<N;j++){cout<<name[j]<<":";cin>>Request[j];//输入需要申请的资源}for (j=0;j<N;j++){if(Request[j]>Need[i][j])//判断申请是否大于需求,若大于则出错{cout<<"进程 "<<i<<"申请的资源大于它需要的资源";cout<<" 分配不合理,不予分配!"<<endl;ch='n';break;}else {if(Request[j]>Avaliable[j])//判断申请是否大于当前资源,若大于则 { //出错cout<<"进程"<<i<<"申请的资源大于系统现在可利用的资源";cout<<" 分配出错,不予分配!"<<endl;ch='n';break;}}}if(ch=='y') {changdata(i);//根据进程需求量变换资源showdata();//根据进程需求量显示变换后的资源safe();//根据进程需求量进行银行家算法判断}}void addresources(){//添加资源int n,flag;cout<<"请输入需要添加资源种类的数量:";cin>>n;flag=N;N=N+n;for(int i=0;i<n;i++){cout<<"名称:";cin>>name[flag];cout<<"数量:";cin>>Avaliable[flag++];}showdata();safe();}void delresources(){//删除资源char ming;int i,flag=1;cout<<"请输入需要删除的资源名称:";do{cin>>ming;for(i=0;i<N;i++)if(ming==name[i]){flag=0;break;}if(i==N)cout<<"该资源名称不存在,请重新输入:";}while(flag);for(int j=i;j<N-1;j++){name[j]=name[j+1];Avaliable[j]=Avaliable[j+1];}N=N-1;showdata();safe();}void changeresources(){//修改资源函数cout<<"系统目前可用的资源[Avaliable]:"<<endl; for(int i=0;i<N;i++)cout<<name[i]<<":"<<Avaliable[i]<<endl; cout<<"输入系统可用资源[Avaliable]:"<<endl; cin>>Avaliable[0]>>Avaliable[1]>>Avaliable[2]; cout<<"经修改后的系统可用资源为"<<endl;for (int k=0;k<N;k++)cout<<name[k]<<":"<<Avaliable[k]<<endl; showdata();safe();}void addprocess(){//添加作业int flag=M;M=M+1;cout<<"请输入该作业的最打需求量[Max]"<<endl; for(int i=0;i<N;i++){cout<<name[i]<<":";cin>>Max[flag][i];Need[flag][i]=Max[flag][i]-Allocation[flag][i];}showdata();safe();}int main()//主函数{int i,j,number,choice,m,n,flag;char ming;cout<<"*****************资源管理系统的设计与实现*****************"<<endl; cout<<"请首先输入系统可供资源种类的数量:";cin>>n;N=n;for(i=0;i<n;i++){cout<<"资源"<<i+1<<"的名称:";cin>>ming;name[i]=ming;cout<<"资源的数量:";cin>>number;Avaliable[i]=number;}cout<<endl;cout<<"请输入作业的数量:";cin>>m;M=m;cout<<"请输入各进程的最大需求量("<<m<<"*"<<n<<"矩阵)[Max]:"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++)cin>>Max[i][j];do{flag=0;cout<<"请输入各进程已经申请的资源量("<<m<<"*"<<n<<"矩阵)[Allocation]:"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++){cin>>Allocation[i][j];if(Allocation[i][j]>Max[i][j])flag=1;Need[i][j]=Max[i][j]-Allocation[i][j];}if(flag)cout<<"申请的资源大于最大需求量,请重新输入!\n";}while(flag);showdata();//显示各种资源safe();//用银行家算法判定系统是否安全while(choice){cout<<"**************银行家算法演示***************"<<endl; cout<<" 1:增加资源 "<<endl;cout<<" 2:删除资源 "<<endl;cout<<" 3:修改资源 "<<endl;cout<<" 4:分配资源 "<<endl;cout<<" 5:增加作业 "<<endl;cout<<" 0:离开 "<<endl;cout<<"*******************************************"<<endl; cout<<"请选择功能号:";cin>>choice;switch(choice){case 1: addresources();break;case 2: delresources();break;case 3: changeresources();break;case 4: share();break;case 5: addprocess();break;case 0: choice=0;break;default: cout<<"请正确选择功能号(0-5)!"<<endl;break;}}return 1;}五、实验结论1、实验结果多资源银行家算法测试的结果如图所示:图1图2图1所示的是:系统中有3个可用的资源a b c,数量都是10,系统中有3个作业,他们最大需求量分别是1 2 3、1 2 3、1 2 3,而他们已经申请的资源是1 1 1、1 1 1、1 1 1,由于系统可用的资源a b c 都是10个,通过银行家算法可以使得任何一个作业完成释放自己得到的资源,从而使得整个系统正常运行,系统是安全。