死锁的避免实验报告
操作系统实验报告-死锁的避免

操作系统实验报告-死锁的避免操作系统实验(二)死锁的避免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]; //需求矩阵};②程序总体框图四、源程序五、程序运行结果六、实验总结银行家算法是一个经典的避免死锁的算法,它可以有效的避免资源分配时产生死锁。
但死锁的避免时相当复杂的,而且浪费时间。
每次分配时都要进行分配检查看是否会产生死锁,通过实验加深对银行家算法的了解和认识,同时对避免死锁的机制也有所了解。
实验不仅锻炼了我动手能力,也巩固了我课堂所学的知识。
只有在实验过程中我们才能深刻的认识到课本知识的重要性。
实验采用银行家算法避免在资源分配时产生死锁现象。
- 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个,通过银行家算法可以使得任何一个作业完成释放自己得到的资源,从而使得整个系统正常运行,系统是安全。