课程设计报告.docx
《课程设计报告.docx》由会员分享，可在线阅读，更多相关《课程设计报告.docx（22页珍藏版）》请在冰点文库上搜索。
课程设计报告
课程设计报告
（2012--2013年度第二学期）
课程名称:
操作系统课程设计
课设题目:
SPOOLING假脱机输入输出技术模拟
院系:
控制与计算机工程学院
班级:
信安1101班
姓名:
陈立翼
指导教师:
贾静平
设计周数:
一周
成绩:
2013年7月5日
一、
需求分析
设计一个实现SPOOLING技术的进程。
要求设计一个SPOOLING输出进程和两个请求输出的用户进程，以及一个SPOOLING输出服务程序。
当请求输出的用户进程希望输出一系列信息时，调用输出服务程序，由输出服务程序将该信息送入输出井。
待遇到一个输出结束标志时，表示进程该次的输出文件输出结束。
之后，申请一个输出请求块（用来记录请求输出的用户进程的名字、信息在输出井中的位置、要输出信息的长度等），等待SPOOLING进程进行输出。
SPOOLING输出进程工作时，根据请求块记录的各进程要输出的信息，将其实际输出到打印机或显示器。
这里，SPOOLING输出进程与请求输出的用户进程可并发运行。
2、整体功能及设计
1.功能划分
Ⅰ.主函数（main）
主函数负责界面的设计，每个进程将要请求的文件数目的读取和进程的调度。
每个用户进程请求输出文件的个数由用户从键盘输入而定。
当用户进程将其所有文件输出完时，终止运行。
进程调度采用随机算法，这与进程输出信息的随机性相一致。
两个请求输出的用户进程的调度概率各为45％，SP00LING输出进程为10％，这由随机数发生器产生的随机数来模拟决定。
进程基本状态有3种，分别为可执行、等待和结束。
可执行态就是进程正在运行或等待调度的状态；等待状态又分为等待状态1、等待状态2和等待状态3。
状态变化的条件为：
①进程执行完成时，置为“结束”态。
②服务程序在将输出信息送输出井时，如发现输出井已满，将调用进程置为“等待状态1”。
③SP00LING进程在进行输出时，若输出井空，则进入“等待状态2”。
④SP00LING进程输出一个信息块后，应立即释放该信息块所占的输出井空间，并将正在等待输出的进程置为“可执行状态”。
⑤服务程序在输出信息到输出井并形成输出请求信息块后，若SP00LING进程处于等待态，则将其置为“可执行状态”。
⑥当用户进程申请请求输出块时，若没有可用请求块时，调用进程进人“等待状态3”。
Ⅱ.用户请求输出进程（askOutput）
用户请求输出进程输出一系列信息，本程序中，信息由随机数产生，然后将该信息送入输出井。
待遇到一个输出结束标志时，即信息为0时，表示进程该次的输出文件输出结束。
之后，申请一个输出请求块，并在其中记录请求输出的用户进程的名字、信息在输出井中的位置、要输出信息的长度等，等待SPOOLING进程进行输出。
Ⅲ.SPOOLING输出进程（Output）
根据请求块记录的各进程要输出的信息，将其实际输出到打印机或显示器。
本程序采用对应的文本区代替打印机和显示器，显示要输出的信息。
2.流程图
Ⅰ.主函数流程图
图1主函数流程图
Ⅱ.用户请求输出进程流程图
图2用户请求输出进程流程图
Ⅲ.SPOOLING输出进程流程图
图3SPOOLING输出进程流程图
三、编程实现
1.数据结构
Ⅰ.输出井
①整型数组buffer[2][100]：
分别存储两个输出井的内容，SP00LING系统为每个请求输出的进程在输出井中分别开辟一个区。
本实验可设计一个二维数组作为输出井。
每个进程在输出井最多可占用100个位置。
②整型数组c1[2]：
分别存储两个输出井的剩余可使用空间
③整型数组c2[2][2]：
分别存储两个输出井的第一个空缓冲指针和第一个满缓冲指针
Ⅱ.请求输出块
①类publicclassreqblock{
intreqname;//请求进程名
intlength;//本次输出信息长度
intaddr;//信息在输出井的首地址
}：
存储请求输出块的内容
②整型c3：
存储剩余可用的请求输出块数
③整型Ptr1：
存储要输出的第一个请求输出块指针，初值为0
④整型Ptr2：
存储空闲请求输出块的指针，初值为0
Ⅲ.进程控制块PCB
publicclasspcb{
intid;//进程标识数
intstatus;//进程状态
intcount;//要输出的文件数
intx;//进程输出时的临时变量
}
其中，status=
0为可执行态；
1为等待状态1，表示输出井满，请求输出的用户进程等待；
2为等待状态2，表示请求输出井空，SP00LING输出进程等待；
3为等待状态3，表示请求输出井满，请求输出的用户进程等待；
4为结束态，进程执行完成。
2.代码实现
publicclassreqblock{
intreqname;//请求进程名
intlength;//本次输出信息长度
intaddr;//信息在输出井的首地址
publicreqblock（）{
reqname=0;
length=0;
addr=0;
}
}
publicclasspcb{
intid;//进程标识数
intstatus;//进程状态
intcount;//要输出的文件数
intx;//进程输出时的临时变量
publicpcb（）{
id=0;
status=0;
count=0;
x=0;
}
}
importjava.awt.event.ActionEvent;
importjava.awt.event.ActionListener;
importjava.util.Random;
importjava.util.*;
importjavax.swing.*;
importjava.awt.*;
publicclassSpoolingextendsJFrameimplementsActionListener{
staticpcbPCB[];//进程控制块
staticreqblockblock[];//请求输出块
staticintbuffer[][];//输出井，每个进程占100
staticintc1[];//两个进程可使用的井空间，初始值为100
staticintc2[][];//空指针满指针
staticintc3;
staticintPtr1,Ptr2;//第一个请求输出块，空闲输出块block
JPanelp1,p2,p3,p4;
JScrollPanep[]=newJScrollPane[4];
JLabell1,l2,l3,l4,l5,l6;
JButtonOK;
JTextFieldnum1,num2;
JTextAreaarea[]=newJTextArea[4];//4
publicSpooling（）{
l1=newJLabel（"第一个进程输出文件数：
"）;
l2=newJLabel（"第二个进程输出文件数：
"）;
l3=newJLabel（"概率和调用进程"）;
l4=newJLabel（"第一个请求进程请求内容"）;
l5=newJLabel（"第二个请求进程请求内容"）;
l6=newJLabel（"SPOOLING输出内容及所属请求进程"）;
OK=newJButton（"确定"）;
for（intb=0;b<4;b++）{
area[b]=newJTextArea（10,10）;
p[b]=newJScrollPane（area[b]）;
}
num1=newJTextField（10）;
num2=newJTextField（10）;
p1=newJPanel（）;
p1.add（l1）;
p1.add（num1）;
p1.add（l2）;
p1.add（num2）;
p1.add（OK）;
p2=newJPanel（）;
p2.setLayout（newGridLayout（1,4））;
p2.add（l3）;
p2.add（l4）;
p2.add（l5）;
p2.add（l6）;
p3=newJPanel（）;
p3.setLayout（newGridLayout（1,4））;
for（intb=0;b<4;b++）{
p3.add（p[b]）;
}
p4=newJPanel（）;
p4.setLayout（newGridLayout（2,1））;
p4.add（p1）;
p4.add（p2）;
getContentPane（）.add（p4,"North"）;
getContentPane（）.add（p3,"Center"）;
setSize（900,500）;
setVisible（true）;
OK.addActionListener（this）;
}
publicvoidactionPerformed（ActionEvente）{
PCB=newpcb[3];
block=newreqblock[10];
buffer=newint[2][100];
c1=newint[2];
c2=newint[2][2];
c3=10;
Ptr1=0;
Ptr2=0;
Randomrdn=newRandom（）;//随机数
inti=0;
///////初始化
for（i=0;i<2;i++）{
c1[i]=100;
}
for（i=0;i<2;i++）{
for（intj=0;j<100;j++）{
buffer[i][j]=0;
}
}
for（i=0;i<2;i++）{
for（intj=0;j<2;j++）{
c2[i][j]=0;
}
}
for（i=0;i<10;i++）{
block[i]=newreqblock（）;
}
PCB[0]=newpcb（）;
PCB[1]=newpcb（）;
PCB[2]=newpcb（）;
PCB[0].count=Integer.parseInt（num1.getText（）.trim（））;//读入文件数
PCB[1].count=Integer.parseInt（num2.getText（）.trim（））;//读入文件数
//////开始
while（PCB[0].status!
=4||PCB[1].status!
=4||PCB[2].status!
=4）
{////三个进程没结束
intx;
x=rdn.nextInt（100）;//产生100以内的随机数
area[0].append（"概率为"+x+"\n"）;
System.out.println（"概率为"+x）;
if（x<=45&&PCB[0].status==0）{
askOutput（0,area[1]）;
area[0].append（"执行请求进程0\n"）;
}
if（45askOutput（1,area[2]）;
area[0].append（"执行请求进程1\n"）;
}
if（x>55&&PCB[2].status==0）{
Output（area[3]）;
area[0].append（"执行SPOOLING进程\n"）;
}
}
}
publicstaticvoidmain（String[]args）{
Spoolings=newSpooling（）;
}
publicstaticvoidaskOutput（inta,JTextAreaarea）{
intcc=0;
intlength=0;
intstart=c2[a][0];
while（cc==0）{
cc=1;
if（c1[a]==0）{//输出井满，该请求进程被阻塞
PCB[a].status=1;
c1[a]=c1[a]+length;
c2[a][0]=c2[a][0]-length;
while（c2[a][0]<0）{
c2[a][0]+=100;
}
area.append（"\n输出井满，"+a+"请求进程阻塞111\n"）;
System.out.println（"\n输出井满，"+a+"请求进程阻塞111"）;
return;
}elseif（Ptr1==（Ptr2+1）%10）{//无空闲请求块
PCB[a].status=3;
area.append（"无空闲请求块"+a+"进程阻塞333\n"）;
System.out.println（"无空闲请求块"+a+"进程阻塞333"）;
return;
}else{
Randomr=newRandom（）;
PCB[a].x=r.nextInt（9）;
if（length==0）{
area.append（"随机数：
"）;
System.out.print（"随机数：
"）;
}
area.append（PCB[a].x+""）;
System.out.print（PCB[a].x+""）;///
if（PCB[a].x!
=0）{
buffer[a][c2[a][0]]=PCB[a].x;
c1[a]=c1[a]-1;
c2[a][0]=（c2[a][0]+1）%100;
length++;
}
if（PCB[a].x==0）{//文件输出结束
PCB[a].count--;
area.append（"\nlength:
"+length+"\n"）;
System.out.println（"\naskoutputprogress"+a+":
length"+length）;
block[Ptr2].length=length;
length=0;
block[Ptr2].reqname=a;
block[Ptr2].addr=start;
start=c2[a][0];
Ptr2=（Ptr2+1）%10;
c3--;
if（PCB[2].status==2）{//将SPOOLING进程变为可执行态
PCB[2].status=0;
area.append（"SPOOLING可执行\n"）;
System.out.println（"SPOOLING可执行"）;
}
if（PCB[a].count==0）{//文件全部输出完
PCB[a].status=4;
area.append（a+"进程完成"）;
System.out.println（a+"进程完成"）;
return;
}else{
cc=0;
}
}else{
cc=0;
}
}
}
}
publicstaticvoidOutput（JTextAreaarea）{
intaa=0;
while（aa==0）{
aa=1;
if（Ptr1==Ptr2）{//请求输出块空
if（PCB[0].status==4&&PCB[1].status==4）{//所有进程都完成
PCB[2].status=4;
area.append（"完成！
！
！
\n"）;
System.out.println（"完成！
！
！
"）;
return;
}else{
PCB[2].status=2;
area.append（"请求块空，没有可以输出的内容，SPOOLING阻塞\n"）;
System.out.println（"请求块空，没有可以输出的内容，SPOOLING阻塞"）;
return;
}
}else{
inty=block[Ptr1].addr;
intx=block[Ptr1].reqname;
area.append（"outputprogress"+x+":
"）;
System.out.print（"outputprogress"+x+":
"）;
for（intd=y;darea.append（buffer[x][d%100]+""）;
System.out.print（buffer[x][d%100]+""）;
c1[x]++;
c2[x][1]=（c2[x][1]+1）%100;
}////
area.append（"\n"）;
System.out.println（）;
Ptr1=（Ptr1+1）%10;
c3++;
if（PCB[0].status==1||PCB[1].status==1）{
if（PCB[0].status==1）{
PCB[0].status=0;
area.append（"\n0进程输出井满111->可执行态\n"）;
System.out.println（"\n0进程输出井满111->可执行态"）;
}
if（PCB[1].status==1）{
PCB[1].status=0;
area.append（"\n1进程输出井满111->可执行态\n"）;
System.out.println（"\n1进程输出井满111->可执行态"）;
}
}else{
if（PCB[0].status==3||PCB[1].status==3）{
if（PCB[0].status==3）{
PCB[0].status=0;
area.append（"0进程无输出块333->可执行态\n"）;
System.out.println（"0进程无输出块333->可执行态"）;
}
if（PCB[1].status==3）{
PCB[1].status=0;
area.append（"1进程无输出块333->可执行态\n"）;
System.out.println（"1进程无输出块333->可执行态"）;
}
return;
}else{
aa=0;
}
}
}
}
}
}
4、使用说明
1.打开
打开后界面如下
图4程序运行界面
2.运行
在对应的文本输入组件中分别填入两个进程要输出的文件数，文件数必须大于0，点击确定按钮。
进程的调度、两个请求服务进程输出的消息和SPOOLING输出进程的输出会显示在对应的文本域中。
5、结果分析
以第一个进程请求2个文件，第二个进程请求3个文件为例，运行结果如下
图5运行结果
概率为89
请求块空，没有可以输出的内容，SPOOLING阻塞
概率为15
第一个请求进程开始工作，产生随机数
随机数：
43745283130
askoutputprogress0:
length10
SPOOLING可执行
随机数：
0
askoutputprogress0:
length0
0进程完成
概率为9
第一个请求进程已完成，再调度
概率为77
执行SPOOLING进程
outputprogress0:
4374528313
outputprogress0:
请求块空，没有可以输出的内容，SPOOLING阻塞
概率为6
概率为3
第一个请求进程已完成，再调度
概率为21
第一个请求进程已完成，再调度
概率为63
SPOOLING进程阻塞，再调度
概率为92
SPOOLING进程阻塞，再调度
概率为12
第一个请求进程已完成，再调度
概率为3
第一个请求进程已完成，再调度
概率为3
第一个请求进程已完成，再调度
概率为98
SPOOLING进程阻塞，再调度
概率为23
第一个请求进程已完成，再调度
概率为19
第一个请求进程已完成，再调度
概率为61
SPOOLING进程阻塞，再调度
概率为25
第一个请求进程已完成，再调度
概率为8
第一个请求进程已完成，再调度
概率为94
SPOOLING进程阻塞，再调度
概率为37
第一个请求进程已完成，再调度
概率为53
第二个请求进程开始工作，产生随机数
随机数：
5870
askoutputprogress1:
length3
SPOOLING可执行
随机数：
6170
askoutputprogress1:
length3
随机数：
270
askoutputprogress1:
length2
1进程完
升级会员 