操作系统课程设计

第一篇：操作系统课程设计

操作系统课程设计

注意事项：

0. 请每位同学必须按时提交课程设计报告(包括电子版和纸质版)，算入期末成绩

1. 在三个题目中选择一个

2. 如果选择题目

(一)进程调度算法，要求实现其中2个以上(包括2个)进程调度算法 3. 如果选择题目

(二)银行家算法，要求能够判断系统的安全状态

4. 如果选择题目

(三)页面调度算法，要求实现其中2个以上(包含2个)进程调度算法 5. 报告应包含算法分析、实验截图、核心算法源代码，请各位同学认真对待，独立完成 6. 提交要求：电子版(包括实验程序)请发至ropeal@163.com，纸质版请班长收齐，由班长统一在课堂上提交(并提交未交人员名单)，截止时间第16周周三(2014.1.31) 7. 格式要求：

7.1 A4纸10页左右

7.2 封面请注明班级、姓名、学号、所选题目

7.3 电子版发送时，请打包成一个文件，将文件名设置为：学号+姓名+题目名称(如20130000张三进程调度算法课程设计)，邮件主题同文件名

一、 进程调度算法

1.1 实验目的： a、设计进程控制块PCB表结构，模拟实现进程调度算法：FIFO，静态优先级调度，时间片轮转调度，多级反馈队列调度。(实现其中之二)。* b、建立进程就绪队列。对不同算法编制入链子程序。 c、编写一进程调度程序模拟程序。模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。 * 由用户输入进程名和进程长度，然后按照短进程优先的进程处理顺序给出进程的排序。

1.2 实验原理 调度算法是指：根据系统的资源分配策略所规定的资源分配算法。 1.2.1 先来先服务和短作业(进程)优先调度算法

1. 先来先服务调度算法。先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度， 也可用于进程调度。FCFS算法比较有利于长作业(进程)，而不利于短作业(进程)。由此可知，本算法适合于CPU繁忙型作业， 而不利于I/O繁忙型的作业(进程)。

2. 短作业(进程)优先调度算法。短作业(进程)优先调度算法(SJ/PF)是指对短作业或短进程优先调度的算法，该算法既可用于作业调度， 也可用于进程调度。但其对长作业不利;不能保证紧迫性作业(进程)被及时处理;作业的长短只是被估算出来的。 1.2.2 高优先权优先调度算法

1. 优先权调度算法的类型。为了照顾紧迫性作业，使之进入系统后便获得优先处理，引入了最高优先权优先(FPF)调度算法。 此算法常被用在批处理系统中，作为作业调度算法，也作为多种操作系统中的进程调度，还可以用于实时系统中。当其用于作业调度， 将后备队列中若干个优先权最高的作业装入内存。当其用于进程调度时，把处理机分配给就绪队列中优先权最高的进程，此时， 又可以进一步把该算法分成以下两种： 1)非抢占式优先权算法

2)抢占式优先权调度算法(高性能计算机操作系统)

2. 优先权类型 。对于最高优先权优先调度算法，其核心在于：它是使用静态优先权还是动态优先权， 以及如何确定进程的优先权。 3.高响应比优先调度算法

为了弥补短作业优先算法的不足，我们引入动态优先权，使作业的优先等级随着等待时间的增加而以速率a提高。 该优先权变化规律可描述为：优先权=(等待时间+要求服务时间)/要求服务时间;即 =(响应时间)/要求服务时间 1.2.3 基于时间片的轮转调度算法

1. 时间片轮转法。时间片轮转法一般用于进程调度，每次调度，把CPU分配队首进程，并令其执行一个时间片。 当执行的时间片用完时，由一个记时器发出一个时钟中断请求，该进程被停止，并被送往就绪队列末尾;依次循环。 2. 多级反馈队列调度算法 多级反馈队列调度算法多级反馈队列调度算法，不必事先知道各种进程所需要执行的时间，它是目前被公认的一种较好的进程调度算法。 其实施过程如下：

1) 设置多个就绪队列，并为各个队列赋予不同的优先级。在优先权越高的队列中， 为每个进程所规定的执行时间片就越小。

2) 当一个新进程进入内存后，首先放入第一队列的末尾，按FCFS原则排队等候调度。 如果他能在一个时间片中完成，便可撤离;如果未完成，就转入第二队列的末尾，在同样等待调度„„ 如此下去，当一个长作业(进程)从第一队列依次将到第n队列(最后队列)后，便按第n队列时间片轮转运行。 3) 仅当第一队列空闲时，调度程序才调度第二队列中的进程运行;仅当第1到第(i-1)队列空时， 才会调度第i队列中的进程运行，并执行相应的时间片轮转。 4) 如果处理机正在处理第i队列中某进程，又有新进程进入优先权较高的队列， 则此新队列抢占正在运行的处理机，并把正在运行的进程放在第i队列的队尾。

1.3 实验要求

a、使用模块化设计思想来设计; b、给出算法的流程图或伪码说明。 c、学生可按照自身条件，随意选择采用的算法，(例如：采用冒泡法编写程序，实现短进程优先调度的算法)

d、进程调度程序模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。

1.4 算法简析 a、每个进程可有三个状态，并假设初始状态为就绪状态。 b、为了便于处理，程序中的某进程运行时间以时间片为单位计算。 各进程的优先数或轮转时间数以及进程需运行的时间片数的初始值均由用户给定。 c、在优先数算法中，优先数可以先取值为(50-该进程所需时间)，进程每执行一次，优先数减3，CPU时间片数(CPUtime)加1， * 进程还需要的时间片数(needtime)减1。在时间片轮转算法中，采用固定时间片

(即：每执行一次进程，该进程的执行时间片数为已执行了2个单位)，这时，CPU时间片(CPUtime)数加2， * 进程还需要的时间片数(needtime)减2，并排列到就绪队列的尾上。

d、对于遇到优先数一致的情况，采用FIFO策略解决。

二、 银行家算法

2.1 概述

2.1.1 设计目的

1、了解多道程序系统中，多个进程并发执行的资源分配。

2、掌握死锁的产生的原因、产生死锁的必要条件和处理死锁的基本方法。

3、掌握预防死锁的方法，系统安全状态的基本概念。

4、掌握银行家算法，了解资源在进程并发执行中的资源分配策略。

5、理解死锁避免在当前计算机系统不常使用的原因

2.2 关于死锁

2.2.1 死锁概念：

在多道程序系统中，虽可借助于多个进程的并发执行，来改善系统的资源利用率，提高系统的吞吐量，但可能发生一种危险━━死锁。所谓死锁(Deadlock),是指多个进程在运行中因争夺资源而造成的一种僵局(Deadly_Embrace),当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。一组进程中，每个进程都无限等待被该组进程中另一进程所占有的资源，因而永远无法得到的资源，这种现象称为进程死锁，这一组进程就称为死锁进程。

2.2.2 关于死锁的一些结论：

参与死锁的进程最少是两个(两个以上进程才会出现死锁)

参与死锁的进程至少有两个已经占有资源

参与死锁的所有进程都在等待资源

参与死锁的进程是当前系统中所有进程的子集

注：如果死锁发生，会浪费大量系统资源，甚至导致系统崩溃。

2.2.3 资源分类：

永久性资源： 可以被多个进程多次使用(可再用资源)，分为：可抢占资源与不可抢占资源

临时性资源：只可使用一次的资源;如信号量,中断信号，同步信号等(可消耗性资源)

“申请--分配--使用--释放”模式

2.2.4 产生死锁的四个必要条件：

1、互斥使用(资源独占)

一个资源每次只能给一个进程使用

2、不可强占(不可剥夺)

资源申请者不能强行的从资源占有者手中夺取资源，资源只能由占有者自愿释放

3、请求和保持(部分分配，占有申请)

一个进程在申请新的资源的同时保持对原有资源的占有(只有这样才是动态申请，动态分配)

4、循环等待

存在一个进程等待队列

{P1 , P2 , „ , Pn},

其中P1等待P2占有的资源，P2等待P3占有的资源，„，Pn等待P1占有的资源，形成一个进程等待环路

2.2.5 死锁的解决方案 1 产生死锁的例子

申请不同类型资源产生死锁

P1： „

申请打印机 申请扫描仪 使用

释放打印机 释放扫描仪 „ P2： „

申请扫描仪 申请打印机 使用

释放打印机 释放扫描仪 „

申请同类资源产生死锁(如内存)

设有资源R，R有m个分配单位，由n个进程P1,P2,„,Pn(n > m)共享。假设每个进程对R的申请和释放符合下列原则： * 一次只能申请一个单位 * 满足总申请后才能使用 * 使用完后一次性释放

m=2，n=3 资源分配不当导致死锁产生

2死锁预防: 定义:在系统设计时确定资源分配算法，保证不发生死锁。具体的做法是破坏产生死锁的四个必要条件之一

①破坏“不可剥夺”条件

在允许进程动态申请资源前提下规定，一个进程在申请新的资源不能立即得到满足而变为等待状态之前，必须释放已占有的全部资源，若需要再重新申请 ②破坏“请求和保持”条件

要求每个进程在运行前必须一次性申请它所要求的所有资源，且仅当该进程所要资源均可满足时才给予一次性分配 ③破坏“循环等待”条件 采用资源有序分配法：

把系统中所有资源编号，进程在申请资源时必须严格按资源编号的递增次序进行，否则操作系统不予分配。

2.2.6 安全状态与不安全状态

安全状态： 如果存在一个由系统中所有进程构成的安全序列P1，„Pn，则系统处于安全状态。一个进程序列{P1，„，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n)，它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和，系统处于安全状态 (安全状态一定是没有死锁发生的) 。

不安全状态:不存在一个安全序列，不安全状态一定导致死锁。

2.3 数据结构设计

1.可利用资源向量矩阵AVAILABLE。这是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态地改变。如果AVAILABLE [j]= K，则表示系统中现有R类资源K个

2.最大需求矩阵MAX。这是一个n*m的矩阵，用以表示每一个进程对m类资源的最大需求。如果MAX [i,j]=K，则表示进程i需要R类资源的数目为K。

3.分配矩阵ALLOCATION。这也是一个n*m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。如果ALLOCATION [i,j]=K，则表示进程i当前已分得R类资源的数目为K。

4.需求矩阵NEED。这也是一个n*m的矩阵，用以表示每一个进程尚需的各类资源数。如果NEED [i,j]=K，则表示进程i还需要R类资源K个，才能完成其任务。 上述矩阵存在下述关系：

NEED [i,j]= MAX[i,j]﹣ ALLOCATION[i,j]

2.4 算法的实现 2.4.1 初始化 由用户输入数据，分别对可利用资源向量矩阵AVAILABLE、最大需求矩阵MAX、分配矩阵ALLOCATION、需求矩阵NEED赋值。 2.4.2 银行家算法

在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性能。在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。

银行家算法的基本思想是分配资源之前,判断系统是否是安全的;若是,才分配。它是最具有代表性的避免死锁的算法。

设进程cusneed提出请求REQUEST [i]，则银行家算法按如下规则进行判断。 (1)如果REQUEST [cusneed] [i]<= NEED[cusneed][i]，则转(2);否则，出错。

(2)如果REQUEST [cusneed] [i]<= AVAILABLE[cusneed][i]，则转(3);否则，出错。 (3)系统试探分配资源，修改相关数据： AVAILABLE[i]-=REQUEST[cusneed][i]; ALLOCATION[cusneed][i]+=REQUEST[cusneed][i]; NEED[cusneed][i]-=REQUEST[cusneed][i]; (4)系统执行安全性检查，如安全，则分配成立;否则试探险性分配作废，系统恢复原状，进程等待。

2.4.3 安全性检查算法

(1)设置两个工作向量Work=AVAILABLE;FINISH (2)从进程集合中找到一个满足下述条件的进程，

FINISH==false; NEED<=Work; 如找到，执行(3);否则，执行(4) (3)设进程获得资源，可顺利执行，直至完成，从而释放资源。

Work+=ALLOCATION; Finish=true; GOTO 2 (4)如所有的进程Finish= true，则表示安全;否则系统不安全。

三、 页面调度算法 3.1 实验名称

页式虚拟存储管理：页面调度算法 3.2 实验目的

页式虚拟存储器实现的一个难点是设计页面调度(置换)算法，即将新页面调入内存时，如果内存中所有的物理页都已经分配出去，就要按某种策略来废弃某个页面，将其所占据的物理页释放出来，供新页面使用。本实验的目的是通过编程实现几种常见的页面调度(置换)算法，加深读者对页面思想的理解。 3.3 实验原理

页面调度算法

目前有许多页面调度算法，本实验主要涉及先进先出调度算法、最近最少调度算法、最近最不常用调度算法。本实验使用页面调度算法时作如下假设，进程在创建时由操作系统为之分配一个固定数目物理页，执行过程中物理页的数目和位置不会改变。也即进程进行页面调度时只能在分到的几个物理页中进行。

下面对各调度算法的思想作一介绍。

<1> 先进先出调度算法

先进先出调度算法根据页面进入内存的时间先后选择淘汰页面，先进入内存的页面先淘汰，后进入内存的后淘汰。本算法实现时需要将页面按进入内存的时间先后组成一个队列，每次调度队首页面予以淘汰。

<2>最近最少调度算法

先进先出调度算法没有考虑页面的使用情况，大多数情况下性能不佳。根据程序执行的局部性特点，程序一旦访问了某些代码和数据，则在一段时间内会经常访问他们，因此最近最少用调度在选择淘汰页面时会考虑页面最近的使用，总是选择在最近一段时间以来最少使用的页面予以淘汰。算法实现时需要为每个页面设置数据结构记录页面自上次访问以来所经历的时间。

<3>最近最不常用调度算法

由于程序设计中经常使用循环结构，根据程序执行的局部性特点，可以设想在一段时间内经常被访问的代码和数据在将来也会经常被访问，显然这样的页面不应该被淘汰。最近最不常用调度算法总是根据一段时间内页面的访问次数来选择淘汰页面，每次淘汰访问次数最少的页面。算法实现时需要为每个页面设置计数器，记录访问次数。计数器由硬件或操作系统自动定时清零。

缺页调度次数和缺页中断率、缺页置换率计算

缺页中断次数是缺页时发出缺页中断的次数。

缺页中断率=缺页中断次数/总的页面引用次数*100%

缺页调度次数是调入新页时需要进行页面调度的次数

缺页置换率=缺页调度次数/总的页面引用次数*100% 3.4 实验内容

(1)设计程序实现以上三种页面调度算法，要求：

①.可以选择页面调度算法类型;

②.可以为进程设置分到物理页的数目，设置进程的页面引用情况，可以从键盘输入页面序列，也可从文件中读取;

③.随时计算当前的页面调度次数的缺页中断率;

④.使用敲键盘或响应WM-TIMER的形式模仿时间的流逝;

⑤.以直观的的形式将程序的执行情况显示在计算机屏幕上;

⑥.存盘及读盘功能，可以随时将数据存入磁盘文件，供以后重复实验时使用。

(2)假定进程分配到3个物理块，对于下面的页面引用序列： (test.txt)

7-0-1-2-0-3-0-4-2-3-0-3-2-1-2-0-1-7-0-1

请分别用先进和先出调度算法，最近最少用调度算法，最近最不常用调度算法计算缺页中断次数，缺页中断率和缺页调度次数、缺页置换率。

再假定进程分配到

4、5个物理块，重复本实验。

(3)假定进程分配到3个物理块，对于下面的页面引用序列： (test2.txt)

4-3-2-1-4-3-5-4-3-2-1-5-0-7-3-8-9-0-2-1-4-7-3-9

请分别用先进先出调度算法、最近最少用调度算法，最近最不常用调度算法计算缺页中断次数，缺页中断率和缺页调度次数、缺页置换率。

再假定进程分配到

4、5个物理块，重复本实验。

(4)假定进程分配到3个物理块，使用程序的动态页面序列生成算法，生成一个页面序列，将此序列存入磁盘文件。再从磁盘文件读入该序列，用程序分别计算三种算法下的缺页中断次数、缺页中断率和缺页调度次数、缺页置换率。

第二篇：操作系统课程设计大纲

课程名称：操作系统课程设计 课程编码：10110206 英文名称：Course Design of Operating System 学 时： 二周 学 分：2

适用专业：计算机科学与技术、计算机网络工程、计算机软件工程 课程类别：必修

课程性质：学科基础课 先修课程：C++程序设计，数据结构，计算机组成原理 参考教材：

计算机操作系统教程,清华大学出版社，张尧学等,2006.10 现代操作系统，机械工业出版社，陈向群等译，2005.9

一、课程性质与任务

“操作系统基础”是计算机专业的核心专业课，“操作系统课程设计”是理解和巩固操作系统基本理论、原理和方法的重要的实践环节。

操作系统课程主要讲述的内容是计算机操作系统的基本原理及组成，操作系统中常用的设计技巧和方法。它与计算机原理、编译原理、汇编语言、计算机网络、程序设计等专业课程关系十分密切。本课程设计的目的综合应用学生所学知识，建立系统和完整的计算机系统概念，理解和巩固操作系统基本理论、原理和方法;在算法基础上，解决实际问题，提高学生实际应用、编程的能力。

二、课程教学的基本要求

学生针对操作系统课程设计题目所提出的问题，查阅相关资料，利用操作系统中的基本原理和方法，通过分析、设计、编码、调试，实现完整的解决方案。

三、课程设计题目及要求

题目：Linux二级文件系统设计

要求：系统采用两级目录，其中第一级对应于用户账号，第二级对应于用户帐号下的文件;使用内存来模拟外存，进行数据结构设计和操作算法的设计，实现一个文件系统并实现基本的文件操作。

四、课程学时分配

总设计时间：两周

五、课程设计内容与安排

1、问题分析及解决方案确定;

2、形成编程思路;

3、使用具体语言实现算法;

4、上机调试程序;

5、编写课程设计报告.

六、考核方式

考核的内容包括：程序语言描述的科学性、系统性，程序设计的正确性，程序设计文档的系统性可读性，学生的工作态度、动手能力、是否有创新，总结报告的质量。

课程设计结束时，要求学生按照统一格式写出课程设计报告。

以编写的程序和学生实际操作能力为主，参考提问和出勤情况等，综合评定给出成绩。

七、课程的主要参考书

1.现代操作系统，机械工业出版社，陈向群 等译， 2005 2.操作系统原理·技术与编程，机械工业出版社，蒋 静等编著， 2004 3.计算机操作系统,西安电子科技大学出版社，方敏主编,2004.8 4.计算机操作系统(第二版)，西安电子科技大学出版社,汤子灜等编著， 2001 5.操作系统实验指导，清华大学出版社,任爱华等 编著， 2004

制定人： 任德华

审定：

批准：

第三篇：操作系统课程设计3

操作系统课程设计3 一. 银行家算法代码

package sheji;

import java.awt.Color; import java.awt.Dimension; import java.awt.GridLayout; import java.awt.TextField; import java.awt.event.ActionEvent; import java.awt.event.ActionListener;

import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JPanel; import javax.swing.JScrollPane; import javax.swing.JTable; import javax.swing.JTextArea; import javax.swing.JTextField;

public class Banker extends JFrame implements ActionListener{

JTable table1; Object[][] data; JPanel p0,p1,p11,p12,p13,p14,p2,p3,p31,p32,p33,p34,p4; JLabel t1,t2,t3,t4,t5,t6,t7,t8,t9;//t10输出安全序列省去

JButton b1,b2,b3,b6,b5; TextField text01,text02,text03,text5,text6; JTextField[] text1,text2,text3,text4; JTextArea text7;

String s1,s2 = new String(); int M,N,i,j,count = 0,flag = 0; int[][]Max,Need,Allocation; int[] Available,Work,Request,Temp;

public Banker(){ super("211213067 秦瑛 银行家算法模拟系统"); p0 = new JPanel(); p1 = new JPanel(); p11 = new JPanel(); p12 = new JPanel(); p13 = new JPanel(); p14 = new JPanel(); p2 = new JPanel(); p3 = new JPanel(); p31 = new JPanel(); p32 = new JPanel(); p33 = new JPanel(); p34 = new JPanel(); p4 = new JPanel();

p0.setLayout(new GridLayout(4,1)); p1.setLayout(new GridLayout(4,1)); p3.setLayout(new GridLayout(4,1));

p1.add(p11); p1.add(p12); p1.add(p13); p1.add(p14);

p3.add(p31); p3.add(p32); p3.add(p33); p3.add(p34);

p0.add(p1); p0.add(p2); p0.add(p3); p0.add(p4);

t1=new JLabel("进程数"); t2=new JLabel("资源数"); t3=new JLabel("进程号"); t4=new JLabel("已分配资源"); t5=new JLabel("资源最大需求"); t6=new JLabel("可用资源"); t7=new JLabel("请求资源进程号"); t8=new JLabel("请求资源为"); t9=new JLabel("安全检测");

b1=new JButton("确定"); b2=new JButton("添加"); b3=new JButton("确定"); b5=new JButton("请求"); b6=new JButton("安全检测");

text1 = new JTextField[6]; text2 = new JTextField[6]; text3 = new JTextField[6]; text4 = new JTextField[6];

for(int i=0;i<6;i++){

text1[i] = new JTextField(4);

text2[i] = new JTextField(4);

text3[i] = new JTextField(4);

text4[i] = new JTextField(4); }

text01 = new TextField(4); text02 = new TextField(4); text03 = new TextField(4); text5 = new TextField(4); text6 = new TextField(50);

String[] columnNames1 = {"进程号","资源最大需求Max","已分配的资源Allocation","需要的资源Need","可利用的资源Available"}; data = new Object[100][5]; table1 = new JTable (data, columnNames1); table1.setPreferredScrollableViewportSize(new Dimension(550, 100)); table1.setRowHeight (20); table1.doLayout(); JScrollPane pane1 = new JScrollPane (table1);

text7 = new JTextArea(" ",6,40); JScrollPane pane2 = new JScrollPane(text7); text7.setEditable(false);

p11.add(t1); p11.add(text01); p11.add(t2); p11.add(text02); p11.add(b1); p12.add(t3); p12.add(text03); p12.add(b2); p13.add(t4); for(int i=0;i<6;i++)

p13.add(text1[i]); p14.add(t5); for(int i=0;i<6;i++)

p14.add(text2[i]); p2.add(pane1);

p31.add(t6); for(int i=0;i<6;i++)

p31.add(text3[i]); p31.add(b3); p32.add(t7); p32.add(text5); p32.add(t8); for(int i=0;i<6;i++)

p32.add(text4[i]); p33.add(b6); p33.add(b5); p34.add(t9); p34.add(text6); p4.add(pane2);

b1.addActionListener(this); b2.addActionListener(this); b3.addActionListener(this); b5.addActionListener(this); b6.addActionListener(this);

p0.setBackground(Color.lightGray);

setContentPane (p0); this.setVisible(true); this.pack();

}

public void Diguisafe(int k,int n) {//递归求解安全序列函数

int m,a; if(k==n){

for(int j=0;j

Work[j] = Available[j];

if(Safe()==1){

for(a=0;a

s1 += Temp[a]+"->";

s1 +=Temp[a]+""+" ";

count++;

for(int j=0;j

Work[j] = Available[j];

} } else

for(i=k;i<=n;i++){//n全排列

m=Temp[k];

Temp[k]=Temp[i];

Temp[i]=m;

Diguisafe(k+1,n);

m=Temp[k];

Temp[k]=Temp[i];

Temp[i]=m;

} }

public int Safe(){//求是否安全序列

int i; for(i=0;i

if(Small(Temp[i]-1)==1){

CountWork(Temp[i]-1);

continue;

}

else break;

} if(i==M)return 1; else return 0;

}

public void CountWork(int i){//计算工作向量函数

for(int j=0;j

Work[j] = Work[j]+Allocation[i][j];

}

public int Small(int i){//判断是否满足需求函数

int flag = 0; for(int j=0;j

if(Need[i][j]<=Work[j])flag=1;

else{

flag =0;

break;

} } return flag;

} public int Req_need(){//判断是否满足需求资源函数

int flag = 0; for(int i=0;i

if(Need[j-1][i]>=Request[i])flag = 1;

else{

flag=0 ;break;

} } return flag; }

public int Req_ava(){//判断是否满足可用资源数

int flag=0; for(int i=0;i

if(Available[i]>=Request[i]) flag=1;

else

{

flag=0;break;

} } return flag; }

public void Changedata(){//预分配函数

String s_available = new String(); for(int i=0;i

Available[i] = Available[i]-Request[i];

Allocation[j-1][i] = Allocation[j-1][i]+Request[i];

Need[j-1][i] = Need[j-1][i]-Request[i];

s_available += Available[j]+" "; } data[0][4] = s_available; table1.repaint(); text6.setText(" "); text7.setText(" "); }

public void Qingqiu(){//资源请求函数 count = 0; if(Req_need()==1&&Req_ava()==1){//不满足需求

Changedata(); //预分配

} else{

s2 ="不能分配";

text6.setText(s2); } }

public void actionPerformed(ActionEvent e){ if(e.getSource()==b1){

M = Integer.parseInt(text01.getText());

N = Integer.parseInt(text02.getText());

Max = new int[M][N];

Allocation = new int[M][N];

Need = new int[M][N];

Available = new int[N];

Request = new int[N];

Work = new int[N];

Temp = new int[M]; }

if(e.getSource()==b2){ i = Integer.parseInt(text03.getText()); int max,allocation; String s_max,s_need,s_allocation; s_max = new String(); s_need = new String(); s_allocation = new String();

for(int j=0;j

for(int j=0;j

if(e.getSource()==b3){ int available; String s_available=new String(); for(int j=0;j

available = Integer.parseInt(text3[j].getText());

Available[j] = available;

s_available += Available[j]+" "; } data[0][4] = s_available; table1.repaint(); }

if(e.getSource()==b5) { flag =1; //请求

int request; text6.setText(" "); text7.setText(" "); j = Integer.parseInt(text5.getText()); for(int i=0;i

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

Request[i] = request; } Qingqiu(); }

if(e.getSource()==b6){//安全序列

s1=new String();

count=0; Diguisafe(0,M-1); if(count==0&&flag==0){

s2 ="系统处于不安全状态，不能请求"; } else if(count==0&&flag==1){

s2 ="系统处于不安全状态，不能分配"; } else

s2="有"+count+"个安全序列，"; text7.setText(s1); text6.setText(s2); flag = 0; } } public static void main(String[] args){

new Banker(); } } 二. 运行界面

进入界面：

数据填充检测：

第四篇：《操作系统课程设计》题目要求

操作系统课程设计要求

一.设计目的

熟悉Linux编程环境，加强对Linux命令的理解及函数的运用

二.设计内容

1. 在Linux环境下模拟实现简单命令解释器。 (1)要求实现的基本命令包括：

pwd

//显示当前所在目录的路径名

dir <目录名>

//列出指定目录名中的所有目录及文件 cd <目录名或路径>

//改变当前工作目录 newdir <目录名>

//新建目录 deldir <目录名>

//删除目录

exit //退出命令解释程序 (2)可选做的扩展命令包括：

rename <旧文件名> <新文件名> //重命名一个文件或目录

find <目录> -name <待查找的文件名> //在指定的目录及其子目录中查找指定的文件

date //显示当前日期 (3)提示：整个程序的大致框架可参考如下：

while ( exit未被输入 ) {

接收键盘的一行输入

分析输入的命令

对输入的命令进行处理，调用系统函数实现功能

} 2. 设计要求

(1) 设计必须在Linux环境下进行。

(2) 命令解释程序的提示符为：姓名拼音@ (3) 程序编写中不得使用system()系统调用。

(4) 整个程序必须严格经过测试，完成所有基本功能。源程序应有较详尽的注释。

3. 可能用到的系统调用：

open(),close(),read(),write(),creat() chdir(), opendir(),readdir(),rewinddir(),closedir(),rmdir(),mkdir() getcwd(), ftw()

time(), localtime(), asctime() 三. 提交要求：

1. 完成的源程序和可执行程序必须保存在Linux服务器上。

2. 要求实现的基本命令必须全部实现。完成可选做的扩展命令将得到较高的分数。容错性强和功能细节考虑更完全也将得到较高的分数。

3. 每位同学必须完成操作系统课程设计说明书并上交纸质打印版(不少于3000字)，设计说明书格式请从ftp下载《操作系统课程设计说明书(模板)》查看。(学习委员收齐后交到老师办公室)。说明书电子版提交到老师的FTP

11计算机2班的同学： 交给韦婷老师

说明书电子版提交到：ftp://we:345678@10.5.1.

5 请提交到该ftp的“/作业/操作系统课程设计/”文件夹中 每位同学的课程设计说明书按以下格式命名： “班内序号-姓名.doc”

例如：05-李凯.doc

4. 独立完成，不得抄袭，凡是发现抄袭的(无论抄与被抄者)，均不及格。 5. 课程设计上交截止日期： 11月12 日

6. 设计提交后将抽取一部分同学进行答辩，答辩时间另行通知。

注意：

1. Linux服务器远程连接方式：telnet 10.5.1.6 (telnet连接服务器的过程可能需要十几秒，属正常现象，请耐心等待) 2. 登陆的用户名和密码 11计算机2班的同学：

用户名：112班内序号

例如: 11计算机2班的5号同学的用户名是：11205

初始密码：123456

3. 在Linux环境编程，若要使用cin、cout，则必须用

#include using namespace std ; 并使用g++进行编译。

4. 本课程设计所需资料从ftp://we:345678@10.5.1.5 “/下载/操作系统课程设计/” 文件夹中下载。

第五篇：c语言课程设计 学生选修课程系统设计

题目：学生选修课程系统设计

功能：假定有n门课程，每门课程有课程编号，课程名称，课程性质，总学时，授课学时，实验或上机学时，学分，开课学期等信息。试设计一选修课程系统。

分步实施：

1、 初步完成总体设计，搭好框架，确定人机对话界面，确定函数个数;

2、 建立一个文件，将每条记录信息写入文件中并能显示于屏幕上

3、完成上述添加、查找(课程编号、课程名称、课程性质等)、修改等功能。

4、进一步要求：学生选修课程(可选项)

要求：

1、用C语言实现程序设计;

2、利用结构体数组实现信息的数据结构设计;

3、系统的各个功能模块要求用函数的形式实现;

4、界面友好(良好的人机交互)，程序加必要的注释。

课程设计实验报告要求：

1、预习报告：题目、课程设计任务、数据结构、程序的总体设计(算法)、模块划分 。

2、实验总结报告：流程图、主要源程序代码(需打印)、测试情况及调试中问题与解决方案、

小结等。