操作系统实验报告利用银行家算法避免死锁（推荐）_操作系统死锁实验报告

其他范文时间：2020-02-27 10:12:23 收藏本文下载本文

【www.daodoc.com - 其他范文】

操作系统实验报告利用银行家算法避免死锁（推荐）由刀豆文库小编整理，希望给你工作、学习、生活带来方便，猜你可能喜欢“操作系统死锁实验报告”。

计算机操作系统实验报告

题目利用银行家算法避免死锁

一、实验目的：

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

（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 cla OsBanker extends JFrame { // 界面设计

JLabel labelInfo;JLabel labelInfo1;int resourceNum, proceNum;int count = 0;JButton buttonRequest, buttonSetInit, button, button1, buttonsearch,button2;JTextField tf1, tf2;JTextField[] textAvailable;JTextField[][] textAllocation;JTextField[][] textNeed;JTextField textProceName;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];

textProceName = new JTextField(“”);

textProceName.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.setDefaultCloseOperation(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 proce:”);

labelNeedLabel.setBounds(75, 90, 100, 20);

// x,y,width,height

contentPane1.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[] labelProceLabel1 = { new JLabel(“进程1”), new JLabel(“进程2”),new JLabel(“进程3”), new JLabel(“进程4”), new JLabel(“进程5”),new JLabel(“进程6”)};

JLabel[] labelProceLabel2 = { 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

labelProceLabel1[pi].setBounds(0, 0 + pi * 20, 60, 20);labelProceLabel2[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

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

contentPane1.add(textNeed[pi][si], null);

contentPane1.add(textAllocation[pi][si], null);} textProceName.setBounds(80, 430, 50, 20);contentPane1.add(textProceName, null);f1.setSize(550, 500);

f1.setResizable(false);

f1.setTitle(“银行家算法(SXJ)”);

f1.setLocationRelativeTo(null);

f1.setDefaultCloseOperation(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.createLoweredBevelBorder());// 边界

(f2.getContentPane()).add(scrollPane);

f2.setSize(450, 400);

f2.setResizable(false);

f2.setDefaultCloseOperation(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());

proceNum = Integer.parseInt(tf2.getText());

for(int i = 0;i

for(int j = 0;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[proceNum];worked = new int[resourceNum];Finish = new boolean[proceNum];copyVector(worked, available);Safety(0);jt.append(“安全序列数量：” + count);if(flag){

labelInfo1.setText(“当前系统状态：安全”);

f2.setVisible(true);

buttonRequest.setEnabled(true);

textProceName.setEnabled(true);

for(int i = 0;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

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

}

for(int j = 0;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);

textProceName.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[i] = v2[i];} void Add(int[] v1, int[] v2){ for(int i = 0;i

v1[i] += v2[i];} void Sub(int[] v1, int[] v2){ for(int i = 0;i

} v1[i]-= v2[i];boolean Smaller(int[] v1, int[] v2){ boolean value = true;for(int i = 0;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

available[i] = Integer.parseInt(textAvailable[i].getText());} max = new int[proceNum][resourceNum];allocated = new int[proceNum][resourceNum];need = new int[proceNum][resourceNum];for(int i = 0;i

for(int j = 0;j

max[i][j] = Integer.parseInt(textNeed[i][j].getText());

allocated[i][j] = Integer.parseInt(textAllocation[i][j]

.getText());

} } for(int i = 0;i

for(int j = 0;j

need[j][i] = max[j][i]1);

request = new int[resourceNum];

for(int i = 0;i

request[i] = Integer.parseInt(textRequest[i].getText());

}

if(!Smaller(request, need[procename])){