最新整理-操作系统课程设计模板[精品资料].docx
- 文档编号:734945
- 上传时间:2023-04-29
- 格式:DOCX
- 页数:39
- 大小:298.33KB
最新整理-操作系统课程设计模板[精品资料].docx
《最新整理-操作系统课程设计模板[精品资料].docx》由会员分享,可在线阅读,更多相关《最新整理-操作系统课程设计模板[精品资料].docx(39页珍藏版)》请在冰点文库上搜索。
山东科技大学学生课程设计
课程设计说明书
课程名称:
操作系统课程设计
专 业:
计算机科学与技术班级:
2014级1班
设计人:
李云涛
山 东 科 技 大 学
2016年6月
0
山 东 科 技 大 学
课程设计任务书
一、 课程设计题目:
2、进程调度算法模拟 3、进程同步模拟实现 4、内存分配与跟踪 5、磁盘调度算法模拟 二、 设计原始资料:
计算机操作系统网上查询资料
三、 设计应解决下列各主要问题:
1、当生产者进程生产物品时,如果没有空缓冲区可用,那么生产者进程必须等待消费者进程释放出一个空缓冲区。
2、实现先到先服务(FCFX)最短作业优先调度(SJF)高响应比优先调度(抢占式)优先权调度时间片轮转调度。
3、编写一个程序,包括两个线程,一个线程用于模拟内存分配活动,另一个用于跟踪第一个线程的内存行为,要求两个线程之间通过信号量实现同步,模拟内存活动的线程可以从一个文件中读出要进行的内存操作。
4、编写一个程序,包括两个线程,一个线程用于模拟内存分配活动,另一个用于跟踪第一个线程的内存行为,要求两个线程之间通过信号量实现同步,模拟内存活动的线程可以从一个文件中读出要进行的内存操作
5、模拟磁盘调度算法先到先服务(FCFS)磁盘调度算法最短寻道时间优先算法(SSTF)
“电梯”调度算法(SCAN算法)C-SCAN算法LOOK调度算法C-LOOK调度算法。
四、设计说明书应附有下列图纸:
五、小组分工说明:
六、命题发出日期:
2016.03.01设计完成日期:
2016.06.24
38
指导教师评语
成绩:
指导教师(签章):
年 月 日
目 录
目 录 4
一、生产者与消费者问题 5
1.1需求分析 5
1.3详细设计 5
1.4调试分析 5
1.5用户使用说明 5
二、进程调度算法模拟 6
2.1需求分析 6
2.3详细设计 7
2.4调试分析 8
2.5用户使用说明 11
三、进程同步模拟实现 12
3.1需求分析 12
3.3详细设计 14
3.4调试分析 18
3.5用户使用说明 19
四、内存分配与跟踪 20
4.1需求分析 20
4.3详细设计 20
4.4调试分析 25
4.5用户使用说明 27
五、模拟实现磁盘调度算法 28
5.1需求分析 28
5.3详细设计 28
5.4调试分析 36
5.5用户使用说明 38
六、课程设计总结 38
一、生产者与消费者问题
1.1需求分析
1.2概要设计
1.3详细设计
1.3.1设计思想
1.3.2模块设计
1.4调试分析
1.5用户使用说明
二、进程调度算法模拟
2.1需求分析
现在的处理机任务量大,多个进程会不同时先后到达,并且各个进程的工作时间也不一定相同,为了使各个进程间不发生冲突,有条不紊的先后运行,并以最短的时间占用处理机,面对这种发展状况,有必要使用进程调度算法来提高处理机的工作效率。
去选择合适的一种进程调度算法达到理想的效果,可以做到信息的规范管理、科学统计和快速运作,从而减少时间上的浪费。
2.2概要设计
进程控制块PCB:
classPCB{
StringpName;//进程名
intpriority;//优先数
intarriveTime;//到达时间
intrunTime;//需要运行时间
intusedCPUtime;//已用CPU时间
charstatus;//进程状态
}
先到先服务算法类结构:
classFCFS{
intn;//进程数
PCB2pcb[];//进程控制块数组
staticintrunSpeed=500;运行速度
intMinC(intcTime)//返回到达最早的进程号
voidFCFServe()//先到先服务调度方法
voidprintCurrentPCB(PCB2pcb)//输出当前进程
voidprintReadyPCB(intcTime)//输出就绪队列
}
}
最高优先数优先算法类结构:
classPrioritySchedule//优先级调度方法
{
intn;//进程数
PCB2pcb[];//进程控制块数组
staticintrunSpeed=500;运行速度
intMaxP(intcTime);//返回优先级最高的进程号
voidPrioritySche();//优先级调度方法
voidprintCurrentPCB(PCB2pcb)//输出当前进程
voidprintReadyPCB(intcTime);//输出就绪进程
}
2.3详细设计
publicclassPCB{StringpName;//进程名intpriority;//优先数
intarriveTime;//到达时间
intrunTime;//需要运行时间
intusedCPUtime;//已用CPU时间
charstatus;//进程状态
publicPCB(Stringn,intp,intaT,intr,intu,charc)//初始化
{
pName=n;priority=p;arriveTime=aT;runTime=r;usedCPUtime=u;status=c;
}
}
2.3.1设计思想
采用java面向对象的思想,将进程控制块(PCB)、最高优先数优先的调度算法以及先来先服务算法都设计成类,将成员和操作方法封装在其中。
1、构造一个类模拟进程控制块(PCB),包含进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等成员。
2、将高优先数优先的调度算法封装成类,对进程控制块进行算法调度。
3、将先来先服务算法封装成类,对进程控制块进行算法调度。
2.3.2模块设计
2.4调试分析
预设进程为3个:
进程名称:
thread1
优先数:
5
到达时间:
1
需要运行时间:
3已用CPU时间:
0进程状态:
w
进程名称:
thread2
优先数:
4
到达时间:
2
需要运行时间:
2已用CPU时间:
0进程状态:
w
进程名称:
thread3
优先数:
3
到达时间:
3
需要运行时间:
1已用CPU时间:
0进程状态:
w
测试结果:
------------------------
当前系统时间为:
1
正在运行进程为:
thread1
进程优先级5
进程到达时间1
进程所需运行时间3进程已用CPU时间1进程状态r
就绪队列为:
空
------------------------
------------------------
当前系统时间为:
2
正在运行进程为:
thread1
进程优先级5
进程到达时间1
进程所需运行时间3进程已用CPU时间2进程状态r
就绪队列为:
进程名称thread2
进程优先级4
进程到达时间2
进程所需运行时间2进程已用CPU时间0进程状态w
------------------------
------------------------
当前系统时间为:
3
正在运行进程为:
thread1
进程优先级5
进程到达时间1
进程所需运行时间3进程已用CPU时间3进程状态r
就绪队列为:
进程名称thread2
进程优先级4
进程到达时间2
进程所需运行时间2进程已用CPU时间0进程状态w
进程名称thread3
进程优先级3
进程到达时间3
进程所需运行时间1进程已用CPU时间0进程状态w
------------------------
------------------------
当前系统时间为:
3
正在运行进程为:
thread2
进程优先级4
进程到达时间2
进程所需运行时间2进程已用CPU时间1进程状态r
就绪队列为:
进程名称thread3
进程优先级3
进程到达时间3
进程所需运行时间1进程已用CPU时间0进程状态w
------------------------
------------------------
当前系统时间为:
4
正在运行进程为:
thread2
进程优先级4
进程到达时间2
进程所需运行时间2进程已用CPU时间2进程状态r
就绪队列为:
进程名称thread3
进程优先级3
进程到达时间3
进程所需运行时间1进程已用CPU时间0进程状态w
------------------------
------------------------
当前系统时间为:
4
正在运行进程为:
thread3
进程优先级3
进程到达时间3
进程所需运行时间1进程已用CPU时间1进程状态r
就绪队列为:
空
2.5用户使用说明
不需要输入数据,在控制台直接运行即可。
三、进程同步模拟实现
3.1需求分析
生产者和消费者问题是经典的进程同步问题,在这个问题中,生产者不断地向缓冲池中写入数据,而消费者则不断地从缓冲区中读取数据。
生产者进程和消费者进程对缓冲池的操作是互斥的,即当前只有一个进程对这个缓冲池进行操作,在缓冲池已满时,生产者必须等待消费者从缓冲区中读取数据后才能继续操作,而当缓冲池为空时。
消费者必须等待生产者向缓冲池中放入数据后才能继续操作。
生产者:
3.2概要设计
消费者
3.3详细设计
publicclassProduceConsume{
publicstaticvoidmain(String[]args){
SyncStackss=newSyncStack();//建造一个装馒头的框Producerp=newProducer(ss);//新建一个生产者,使之持有框
Consumec=newConsume(ss);//新建一个消费者,使之持有同一个框Threadtp=newThread(p);//新建一个生产者线程
Threadtc=newThread(c);//新建一个消费者线程
tp.start();//启动生产者线程
tc.start();//启动消费者线程
}
}
//馒头类
classSteamBread{intid;//馒头编号
SteamBread(intid){this.id=id;
}
publicStringtoString(){return"steamBread:
"+id;
}
}
//装馒头的框,栈结构classSyncStack{
intindex=0;
SteamBread[]stb=newSteamBread[6];//构造馒头数组,相当于馒头筐,容量是6
//放入框中,相当于入栈
publicsynchronizedvoidpush(SteamBreadsb){
while(index==stb.length){//筐满了,即栈满,try{
this.wait();//让当前线程等待
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblocke.printStackTrace();
}
}
this.notify();//唤醒在此对象监视器上等待的单个线程,即消费者线程stb[index]=sb;
this.index++;
}
//从框中拿出,相当于出栈
publicsynchronizedSteamBreadpop(){
while(index==0){//筐空了,即栈空try{
this.wait();
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblocke.printStackTrace();
}
}
this.notify();
this.index--;//push第n个之后,this.index++,使栈顶为n+1,故
return之前要减一
returnstb[index];
}
}
//生产者类,实现了Runnable接口,以便于构造生产者线程
classProducerimplementsRunnable{SyncStackss=null;Producer(SyncStackss){
this.ss=ss;
}
@Override
publicvoidrun(){
//开始生产馒头
for(inti=0;i<20;i++){
SteamBreadstb=newSteamBread(i);
ss.push(stb);
System.out.println("生产了"+stb);try{
Thread.sleep(10);//每生产一个馒头,睡觉10毫秒
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblocke.printStackTrace();
}
}
}
}
//消费者类,实现了Runnable接口,以便于构造消费者线程
classConsumeimplementsRunnable{SyncStackss=null;
publicConsume(SyncStackss){super();
this.ss=ss;
}
@Override
publicvoidrun(){
//TODOAuto-generatedmethodstubfor(inti=0;i<20;i++){//开始消费馒头
SteamBreadstb=ss.pop();
System.out.println("消费了"+stb);try{
Thread.sleep(100);//每消费一个馒头,睡觉100毫秒。
即生产多个,消费一个
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblocke.printStackTrace();
}
}
}
}
3.3.1设计思想
问题的是指是P、V操作,实验设一个共享缓冲区,生产者和消费者互斥的使用,当一个线程使用缓冲区的时候,另一个让其等待直到前一个线程释放缓冲区为止。
3.3.2模块设计
3.4调试分析
3.5用户使用说明
打开eclipse点running运行输出(数据在函数中已经定义好了
四、内存分配与跟踪
4.1需求分析
编写一个程序,包括两个线程,一个线程用于模拟内存分配活动,另一个用于跟踪第一个线程的内存行为,要求两个线程之间通过信号量实现同步,模拟内存活动的线程可以从一个文件中读出要进行的内存操作
相关数据结构定义
4.2概要设计
空闲分区块类:
classFreeBlock
空闲分区链类:
classFreeList
内存分配回收算法类:
classMemoryManager
测试类(主类):
classTestForMemManage
4.3详细设计
importjava.util.Scanner;
publicclassMemoryManager{
FreeListflist; //空闲分区类对象publicMemoryManager(){
flist=newFreeList();flist.InitFBlock();
}
publicvoidmemAllocation(intsize,Stringnew_job_name){//内存分配(首次适应算法)
FreeBlockq=flist.head;FreeBlockp=flist.head.next;while(p!
=null){
if(size<=0){
System.out.println("\n申请的空间不能小于1!
");break;
}
if(p.state==false&&p.size>=size){
}
else
{
}
}
q=newFreeBlock(p.size-size);p.size=size;
p.state=true;
p.job_name=new_job_name;q.next=p.next;
p.next=q;
break; //完成分配
p=p.next; //移动到足够分配的空闲块
作...");
if(p==null){
if(flist.flistsize>=size){
System.out.println("目前尚无足够大的空闲块,系统将进行重定位操
relocation(); //重定向memAllocation(size,new_job_name);//重新分配内存
}
else{
System.out.println("作业"+new_job_name+"内存尚未分配成功!
");
}
}
else{ //分配内存后可能存在大小为0的空间,将其清除
System.out.println("作业"+new_job_name+"内存分配成功!
");p=flist.head.next;
//q=flist.head;while(p!
=null){
if(p.size==0){
flist.deleteFBlock(p);
}
p=p.next;
}
}
}
privatevoidmemRecovery(FreeBlocktarget){ //内存回收FreeBlockp=flist.head.next;
while(p!
=null){
//回收区与插入点的前一个空闲分区相邻接if(p.next==target&&p.state==false){
p.size+=target.size;p.next=target.next;
//回收区同时与插入点的前后两个空闲分区相邻接if(!
p.next.state){
p.size+=p.next.size;p.next=p.next.next;
}
break;
}
if(p==target){
//回收区与插入点的后一空闲分区相邻接if(!
p.next.state){
target.size+=p.next.size;target.next=p.next.next;
}
break; //若两不邻接,则直接跳出
}
p=p.next;
}
}
privatevoidrelocation(){//空闲资源重定向,回收空闲空间FreeBlockfront_r=flist.head;//
FreeBlockr=front_r.next; //当前重定向空闲块FreeBlockbehind_r=r.next;
while(r!
=null){ //将r定位到第一块空闲分区块
if(r.state==false){break;
}
r=r.next;behind_r=r.next;
front_r=front_r.next; //记录第一块空闲分区的上一块
}
while(behind_r!
=null){if(behind_r.state){
front_r.next=behind_r;
r.next=behind_r.next;behind_r.next=r;front_r=behind_r;
}
else{
r.size+=behind_r.size;r.next=behind_r.next;
}
behind_r=r.next;
}
System.out.println("重定向成功,继续为作业分配内存...");
}
publicvoidaddJob(){ //添加作业
intnewSize; //新作业所需内存大小StringnJobName=newString("");Scannerscanner=newScanner(System.in);
System.out.print("请输入新任务的名称:
");nJobName=scanner.nextLine();
System.out.print("请输入新任务所需内存大小:
");newSize=scanner.nextInt();memAllocation(newSize,nJobName);
}
publicvoiddelJob(){ //销毁作业Stringcur_job_name=newString("");
booleanflag=false; //指示作业是否删除成功FreeBlockq=flist.head.next;
Scannerscanner=newScanner(System.in);
System.out.print("请输入需要回收的作业名称:
");cur_job_name=scanner.nextLine();
while(q!
=null){
if(q.job_name==cur_job_name){q.state=false;
q.job_name="";memRecovery(q);//回收内存flag=true;
break;
}
else{
q=q.next; //找到要删除的作业的下一个结点
}
}
if(flag){
System.out.println("删除作业成功!
");
}
else{
System.out.println("删除作业未成功!
");
}
}
publicvoidprintJobInfo()
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 精品资料 最新 整理 操作系统 课程设计 模板 精品 资料
![提示](https://static.bingdoc.com/images/bang_tan.gif)