江苏科技大学操作系统实验.docx

1、江苏科技大学操作系统实验操作系统实验实验一 进程调度一、实验目的多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略来决定那个进程优先占有处理机。因而引起进程调度。本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。二、实验要求1设计进程调度算法，进程数不定2包含几种调度算法，并加以实现3输出进程的调度过程进程的状态、链表等。三、参考例1题目优先权法、轮转法简化假设1）进程为计算型的（无I/O）2）进程状态：ready、running、finish3）进程需要的CPU时间以时间片为单位确定2算法描述1）优先权法动态优先权当前运行进程用完时间片后，其优先权减去一个常数

2、。2）轮转法四、实验流程图注意：1产生的各种随机数的取值范围加以限制，如所需的CPU时间限制在120之间。2进程数n不要太大通常取48个3使用动态数据结构4独立编程5至少三种调度算法6若有可能请在图形方式下，将PCB的调度用图形成动画显示。五实验过程：（1）输入：进程流文件（1.txt），其中存储的是一系列要执行的进程， 每个作业包括四个数据项：进程名 进程状态(1就绪 2等待 3运行) 所需时间 优先数(0级最高)进程0 1 50 2进程1 2 10 4进程2 1 15 0进程3 3 28 5 进程4 2 19 1进程5 3 8 7输出: 进程执行流等待时间，平均等待时间本程序包括:FIFO

3、算法，优先数调度算法，时间片轮转调度算法（2）程序代码package 进程调度;import java.util.*; class PCB/创建进程块 int Id;/进程编号 int UseTime;/服务时间 int NeedTime;/需要时间 int Perior;/优先级 String Status;/状态 PCB() Id+; UseTime=0; NeedTime=(int)Math.round(Math.random()*6)+1;/随机产生需要时间 Perior=(int)Math.round(Math.random()*5)+1;/随即产生优先级 Status=Ready;

4、/初始状态为就绪 class Found/定义系统处理方法类 ArrayList sequnce;/创建就绪队列 PCB pcb=new PCB5; int StartTime=0; int SystemTime=(int)(Math.random()*3)+1;/随即产生系统时间 Found() sequnce=new ArrayList (); for(int i=0;i0)/就绪队列不为空 Running=sequnce.remove(0); Running.UseTime=Running.NeedTime; Running.NeedTime=0; Running.Perior=0; S

5、ystem.out.println(当前系统时间：+SystemTime); SystemTime+=Running.UseTime; ShowMessages(Running); void RR()/时间片轮换算法 PCB Running=null; int Time=SystemTime; while(sequnce.size()0) System.out.println(当前系统时间：+SystemTime); Running=sequnce.remove(0); if(Running.NeedTime0) System.out.println(当前就绪进程：); for(PCB p1:

6、sequnce) System.out.println(进程编号：+p1.Id+ +服务时间：+p1.UseTime+ +需要时间：+p1.NeedTime+ +优先级：+p1.Perior+ +状态：+p1.Status); System.out.println(-); else System.out.println(当前系统中已经没有就绪进程！); System.out.println(n); class Menu/主界面菜单 Scanner sc=new Scanner(System.in); int print() System.out.println(*); System.out.p

7、rintln( 进调度算法演示); System.out.println(*); System.out.println( 1.先来先服务（FCFS）算法); System.out.println( 2.时间片轮换（RR）算法); System.out.println( 3.退出该程序); System.out.print(请选择所要采用的算法：); int flag=sc.nextInt(); return flag; void select() int flag=print(); switch (flag) case 1: Found Process1=new Found(); Proces

8、s1.FCFS(); print(); case 2: Found Process2=new Found(); Process2.RR(); print(); case 3: System.exit(0); default: break; package 进程调度;public class ProcessControl public static void main(String args) Menu Tencent=new Menu(); Tencent.select(); （3）运行结果：实验二 银行家算法一、实验目的死锁会引起计算机工作僵死，因此操作系统中必须防止。本实验的目的在于让学生

9、独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序，了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生，以加深对课堂上所讲授的知识的理解。二、实验要求设计有n个进程共享m个系统资源的系统，进程可动态的申请和释放资源，系统按各进程的申请动态的分配资源。系统能显示各个进程申请和释放资源，以及系统动态分配资源的过程，便于用户观察和分析；三、数据结构1可利用资源向量Available ，它是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源的数目，其初始值是系统中所配置的该类全部可用资源数目。其数值随该类资源的分配和回收而动态地改变。如果Available（j）=k，

10、标是系统中现有Rj类资源k个。2最大需求矩阵Max，这是一个nm的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max（i，j）=k，表示进程i需要Rj类资源的最大数目为k。3分配矩阵Allocation，这是一个nm的矩阵，它定义了系统中的每类资源当前一分配到每一个进程的资源数。如果Allocation（i，j）=k，表示进程i当前已经分到Rj类资源的数目为k。Allocation i表示进程i的分配向量，有矩阵Allocation的第i行构成。4需求矩阵Need，这是一个nm的矩阵，用以表示每个进程还需要的各类资源的数目。如果Need（i，j）=k，表示进程i还需要R

11、j类资源k个，才能完成其任务。Need i表示进程i的需求向量，由矩阵Need的第i行构成。上述三个矩阵间存在关系：Need（i，j）=Max（i，j）-Allocation（i，j）；四、银行家算法Request i 是进程Pi 的请求向量。Request i （j）=k表示进程Pi请求分配Rj类资源k个。当Pi发出资源请求后，系统按下述步骤进行检查：1如果Request i Need，则转向步骤2；否则，认为出错，因为它所请求的资源数已超过它当前的最大需求量。2如果Request i Available，则转向步骤3；否则，表示系统中尚无足够的资源满足Pi的申请，Pi必须等待。3系统试探性

12、地把资源分配给进程Pi，并修改下面数据结构中的数值：Available = Available - Request iAllocation i= Allocation i+ Request iNeed i= Need i - Request i4系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。如果安全才正式将资源分配给进程Pi，以完成本次分配；否则，将试探分配作废，恢复原来的资源分配状态，让进程Pi等待。假定系统有5个进程（p0,p1,p2,p3,p4）和三类资源（A，B，C），各种资源的数量分别为10，5，7，在T0时刻的资源分配情况如下图： Max Allocation Ne

13、ed Available A B C A B C A B C A B CP0 7 5 3 0 1 0 7 4 3 3 3 2 ( 2 3 0 )P1 3 2 2 2 0 0 1 2 2 (3 0 2 ) (0 2 0 )P2 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 1五、安全性算法1设置两个向量。Work：它表示系统可提供给进程继续运行的各类资源数目，它包含m个元素，开始执行安全性算法时，Work = Available。Finish：它表示系统是否有足够的资源分配给进程，使之运行完成，开始Finish（I）=false；

14、当有足够资源分配给进程Pi时，令Finish（i）=true；2从进程集合中找到一个能满足下述条件的进程。Finish（i）= = false；Need i work；如找到则执行步骤3；否则，执行步骤4；3当进程Pi获得资源后，可顺利执行直到完成，并释放出分配给它的资源，故应执行Work = work + Allocation i Finish（i）=true；转向步骤2；4若所有进程的Finish（i）都为true，则表示系统处于安全状态；否则，系统处于不安全状态。六、系统流程图 七银行家算法程序代码package yinhangjia;import java.util.Scanner;p

15、ublic class banker private int Process = 0; / 定义最大进程数目 private int Resource = 0; / 定义最大资源类数 private int Work; / 定义系统可提供给进程继续运行所需的各类资源数目 private int MAX; / 定义进程最大资源需求 private int Allocation; / 定义进程当前已用资源数目 private int need; / 定义进程需要资源数目 private int Request; / 定义进程请求资源向量 private boolean finish;/ 定义进程完

16、成标志 private int Available; private int P; private Scanner in = new Scanner(System.in); / 定义全局输入流 public void close() in.close(); / 构造函数，初始化各向量 public banker() throws Exception int i, j; System.out.print(请输入当前进程的个数:); Process = in.nextInt(); System.out.print(请输入系统资源种类的类数:); Resource = in.nextInt(); /

17、 初始化各个数组 Available = new intResource; Work = new intResource; MAX = new intProcessResource; Allocation = new intProcessResource; need = new intProcessResource; Request = new intProcessResource; finish = new booleanProcess; P = new intProcess; System.out.println(请输入每个进程最大资源需求量,按 + Process + * + Resou

18、rce + 矩阵输入：); for (i = 0; i Process; i+) System.out.print(请输入P + (i + 1) + 进程各类资源最大需求量:); for (j = 0; j Resource; j+) MAXij = in.nextInt(); System.out.println(请输入每个进程已分配的各资源数,也按照 + Process + * + Resource + 矩阵输入：); for (i = 0; i Process; i+) System.out.print(请输入P + (i + 1) + 进程各类资源已分配 的资源数:); for (j

19、= 0; j Resource; j+) Allocationij = in.nextInt(); needij = MAXij - Allocationij; if (needij 0) System.out.println(您输入的第 + (i + 1) + 个进程所拥有的第 + (j + 1) + 个资源数错误,请重新输入:); j-; continue; System.out.print(请输入系统各类资源可用的数目:); for (i = 0; i Resource; i+) Availablei = in.nextInt(); public void Bank() throws E

20、xception int j, i; int tempAvailable = new intResource; int tempAllocation = new intResource; int tempNeed = new intResource; System.out.println(-); System.out.print(请输入要申请资源的进程号(当前共有 + Process+ 个进程,如为进程P1申请，请输入1，以此类推); i = in.nextInt() - 1; System.out.print(请输入P + (i + 1) + 进程申请的各资源的数量); for (j = 0

21、; j Resource; j+) Requestij = in.nextInt(); for (j = 0; j needij) System.out.println(您输入的申请的资源数超过进程的需求量!请重新输入!); continue; if (Requestij Availablej) System.out.println(您输入的申请数超过系统可用的资源数!请重新输入!); continue; for (j = 0; j Resource; j+) tempAvailablej = Availablej; tempAllocationj = Allocationij; tempNe

22、edj = needij; Availablej = Availablej - Requestij; Allocationij = Allocationij + Requestij; needij = needij - Requestij; if (Safe() System.out.println(分配给P + i + 进程成功!); System.out.print(分配前系统可用资源：); for (int k = 0; k Resource; k+) System.out.print(tempAvailablek + ); System.out.print(n分配前进程P + i +

23、各类资源已分配数量:); for (int k = 0; k Resource; k+) System.out.print(tempAllocationk + ); System.out.print(n分配前进程P + i + 各类资源需求数量:); for (int k = 0; k Resource; k+) System.out.print(tempNeedk + ); System.out.print(n分配后系统可用资源： ); for (int k = 0; k Resource; k+) System.out.print(Availablek + ); System.out.pr

24、int(n分配后进程P + i + 各类资源已分配数量:); for (int k = 0; k Resource; k+) System.out.print(Allocationik + ); System.out.print(n分配后进程P + i + 各类资源需求数量:); for (int k = 0; k Resource; k+) System.out.print(needik + ); System.out.println(); else System.out.println(申请资源失败!); for (j = 0; j Resource; j+) Availablej = A

25、vailablej + Requestij; Allocationij = Allocationij + Requestij; needij = needij + Requestij; for (i = 0; i Process; i+) finishi = false; / 安全性算法 public boolean Safe() int i, j, k, t = 0; Work = new intResource; for (i = 0; i Resource; i+) Worki = Availablei; for (i = 0; i Process; i+) finishi = false;