操作系统实验报告进程调度法的实现Word格式.docx
《操作系统实验报告进程调度法的实现Word格式.docx》由会员分享，可在线阅读，更多相关《操作系统实验报告进程调度法的实现Word格式.docx（18页珍藏版）》请在冰豆网上搜索。
public:
staticvoidRandID（）;
//静态随机生成进程ID的函数
Process（）;
//进程类的构造函数
intgetID（）;
//得到进程ID
intgetIP（）;
//获取进程指令指针IP
voidsetIP（int）;
//设置IP
voidRuned（）;
//进程被执行
intgetUnittime（）;
//得到进程的单位执行时间
intgetBlcoktime（）;
//得到进程被阻塞的时间
voidsetBlocktime（int）;
//设置进程被阻塞的时间
voidsetUnittime（int）;
//设置进程的单位执行时间
chargetResult（int）;
//得到进程被执行的结果
char*getRuntext（）;
//得到进程执行的指令
voidsetBlockstate（bool）;
//设置进程阻塞状态
boolgetBlockstate（）;
//得到进程阻塞状态
boolgetISusesource（）;
//得到资源的使用状态
voidsetISusesource（bool）;
//设置资源的使用状态
};
intProcess:
:
init_ID;
//初始化静态变量
voidProcess:
RandID（）//随机产生一个进程ID
srand（（unsigned）time（NULL））;
//调用srand随机生成函数
init_ID=rand（）;
}
Process:
Process（）//进程的构造函数
ID=init_ID++;
//进程ID的初值为静态初始ID的值
intcommandLen;
//命令行长度
IP=0;
cout<
<
"
PleaseinputthetextwhichprocessrunedbyCPU[#command#]:
>
\\"
;
cin>
runText;
//输入命令
if（（commandLen=strlen（runText））>
MAXCOMMANDLEN）
exit（0）;
//输入长度超出最大长度时退出，特殊情况处理
runText[commandLen]='
#'
//初始指令结束标志'
runText[commandLen+1]='
\0'
//字符串结束标志
ISuseSource=false;
//设置资源的使用状态为未使用
ISblocked=false;
//进程的初始状态-》未被阻塞
unitTime=1;
//进程被执行的单位时间为1
blockTime=0;
//阻塞时间为0
Runed（）//进程被CPU执行
getResult（IP++）;
//输出得到的进程执行结果
getID（）//得到进程ID
returnID;
getIP（）//得到进行IP
returnIP;
setIP（intip）//设置进程IP
IP=ip;
boolProcess:
getISusesource（）//得到资源的使用状态
returnISuseSource;
setISusesource（bools）//设置资源的使用状态
ISuseSource=s;
char*Process:
getRuntext（）//得到进程执行的指令
returnrunText;
getUnittime（）//得到进程的单位执行时间
returnunitTime;
getBlcoktime（）//得到进程阻塞状态
returnblockTime;
setBlocktime（intBT）//设置进程阻塞时间
blockTime=BT;
setUnittime（intUT）//设置进程的单位执行时间
unitTime=UT;
setBlockstate（boolstate）//设置进程阻塞状态
ISblocked=state;
getBlockstate（）//得到进程阻塞状态
returnISblocked;
charProcess:
getResult（intk）//得到程序的运行结果
returnrunText[k];
//SOURCE
classSource//资源类
//资源ID
boolstate;
//资源是否被占用状态
intpro_ID;
//使用资源的进程id
Process*pro;
//使用资源的进程指针
inttime;
//进程使用资源的时间
Source（int）;
//资源类构造函数
boolgetState（）;
//得到资源被使用状态
voidsetState（bool）;
//设置资源被使用状态
voidsetTime（int）;
//设置进程使用资源的时间
voidsetPro（Process*）;
//设置使用该资源的进程
//得到资源id
intgetPorID（）;
//得到使用资源的进程id
voidsetProID（int）;
//设置使用资源的进程id
voidrunned（）;
//资源被cpu调用
Source:
Source（intid）//资源类构造函数
ID=id;
//资源ID初值为id
pro=NULL;
//指针赋为空值
state=true;
//状态为被使用状态
voidSource:
setProID（intid）//设置使用资源的进程id
pro_ID=id;
setTime（intt）//设置进程使用资源的时间
time=t;
setState（bools）//设置资源使用状态
state=s;
boolSource:
getState（）//得到资源使用状态
returnstate;
setPro（Process*p）//设置使用该资源的进程
pro=p;
runned（）//资源被CPU调用
if（time>
0）//时间充足继续运行输出资源信息并使时间减一
{
cout<
（Source:
ID<
）"
time--;
}
if（time<
=0）//时间用完
pro->
setISusesource（false）;
//资源的使用状态为未使用
intip=pro->
getIP（）;
//得到进程的IP
setIP（++ip）;
//设置到下一个ip
Source:
setState（true）;
//设置资源的使用状态为正在使用
endl<
Theprocess"
pro->
getID（）<
relasethesource!
endl;
pro=NULL;
//输出资源被释放指针值赋值为空值
//CPU
typedefstructBlock//阻塞队列结构
Process*p_BlockProcess;
//被阻塞的进程队列
intindex;
//被阻塞的进程在就绪队列中的位置
}Block;
classCPU
Process*p_Process;
//进程队列
Process**pp_Process;
//进程就绪队列
Block*blockQueue;
//进程阻塞队列
Source*p_Source;
//资源指针
intnumOfprocess;
//进程数量
intnumOfblock;
//被阻塞的进程数
intPC;
//程序计数器
intallTime;
//cpu运行的总时间
public:
CPU（int）;
//cpu构造函数
voidRun（）;
//cpu运行进程
bool_IC（Process&
）;
//虚拟IC,进行进程指令翻译
voiduseSource（Process&
//进程申请资源
voidblockProcess（Process&
//阻塞进程
voidreleaseBlockPro（）;
//释放阻塞进程
intgetAlltime（）;
//得到进程运行的总时间
voiddisplayPro（）;
//显示进程的基本信息,id,指令,运行时间等
voidblockTimeADD（）;
//阻塞时间加1
CPU:
CPU（intnum）
p_Source=newSource（379857）;
//创建一个id号为379857的资源
numOfprocess=num;
//进程数
numOfblock=0;
//阻塞数
allTime=0;
//cpu运行的总时间初始化为0
p_Process=newProcess[numOfprocess];
//进程队列申请空间
pp_Process=newProcess*[numOfprocess];
//进程就绪队列申请空间
blockQueue=newBlock[numOfprocess];
//阻塞队列申请空间
for（inti=0;
i<
numOfprocess;
i++）
pp_Process[i]=&
p_Process[i];
//用二维数组存放进程指针数组头指针
blockQueue->
p_BlockProcess=NULL;
//阻塞队列的阻塞进程赋值为空
index=-1;
//阻塞队列的索引值置为1
intCPU:
getAlltime（）//得到进程运行的总时间
returnallTime;
voidCPU:
displayPro（）//显示进程的基本信息
for（inti=0;
i++）//循环输出被执行的进程的信息
\tProcessID:
"
p_Process[i].getID（）<
textofrunned:
p_Process[i].getRuntext（）<
Run（）//cpu运行进程
intnumPro=numOfprocess;
//记录未被运行的进程个数
do
for（intnum=0;
num<
numOfprocess;
num++）
{
if（!
pp_Process[num]）//就绪队列不空继续执行
continue;
for（intt=0;
t<
p_Process[num].getUnittime（）;
t++）
{
PC=p_Process[num].getIP（）;
//得到进程Ip
if（_IC（p_Process[num]））//判断进程的状态TURE进入
{
if（t==0）//时间为0运行完输出进程信息
cout<
theprocess["
p_Process[num].getID（）<
]runed:
if（!
p_Process[num].getISusesource（））//如果该进程未被运行过，则调用run运行
{
p_Process[num].Runed（）;
}
else
p_Source->
runned（）;
//
if（p_Source->
getState（）&
&
numOfblock>
0）
{
releaseBlockPro（）;
////如果进程运行过，现在但未运行，说明为阻塞。
释放阻塞进程，调用它
}
}
else
p_Process[num].getBlockstate（））//该进程不在阻塞状态
numPro--;
//未被运行的进程个数减一
pp_Process[num]=NULL;
//进程就绪队列该位置赋为空值
continue;
break;
//跳出循环
allTime++;
//运行总时间++
if（numOfblock>
0）//如果阻塞个数>
blockTimeADD（）;
}//endfort...
if（p_Process[num].getUnittime（））//该进程的执行单位时间非0
p_Process[num].setUnittime
（1）;
//设置该进程执行的单位时间为1
cout<
}//endfornum...
}while（numPro）;
boolCPU:
_IC（Process&
p）//对进程中的指令进行翻译
charresultRunned;
resultRunned=p.getResult（PC）;
if（resultRunned=='
）//#则是命令行结束
returnfalse;
else
if（resultRunned=='
$'
）//申请资源指令
PC++;
p.setIP（PC）;
resultRunned=p.getResult（PC）;
if（resultRunned>
='
1'
&
resultRunned<
9'
）//资源号1-9，在这区间就进入
if（p_Source->
getState（）//资源未被使用则使用资源
useSource（p）;
cout<
p.getID（）<
takeupthesource!
else//资源已被使用则阻塞进程
blockProcess（p）;
isblocked!
returnfalse;
}
else//'
后跟的不是数字，则语法错误
cout<
Theprocess["
]runnedfail!
Ithasbeenstopped!
returnfalse;
}
returntrue;
blockTimeADD（）//阻塞时间加1
numOfblock;
i++）
intBT=blockQueue[i].p_BlockProcess->
getBlcoktime（）;
//循环得到阻塞队列中每个进程的阻塞时间
blockQueue[i].p_BlockProcess->
setBlocktime（++BT）;
//每个时间+1
useSource（Process&
p）//进程申请资源
p.setISusesource（true）;
//运行的资源的状态设置
p_Source->
setState（false）;
//资源状态设置为不可用
setProID（p.getID（））;
//设置进程ID
setTime（p.getResult（PC）-'
0'
//设置资源使用时间
setPro（&
p）;
//设置使用资源的进程
blockProcess（Process&
p）//阻塞进程
inttempIndex=numOfprocess-（Process:
init_ID-p.getID（））;
//阻塞进程的设置
blockQueue[numOfblock].p_BlockProcess=&
p;
//将进程p加入到阻塞队列尾部
blockQueue[numOfblock].index=tempIndex;
//设置新加进程阻塞队列所在位置的索引值
numOfblock++;
//阻塞进程个数+1
intip=p.getIP（）;
p.setIP（--ip）;
//设置进程的ip
p.setBlockstate（true）;
//设置进程的组设状态为真
p.setBlocktime
（1）;
//设置进程的块阻塞时间为1
p.setUnittime（0）;
//设置进程的单位执行时间为0
pp_Process[tempIndex]=NULL;
//进程就绪队列tempIndex处赋为空值
releaseBlockPro（）//释放阻塞队列的第一个进程，阻塞时间最长
pp_Process[blockQueue[0].index]=blockQueue[0].p_BlockProcess;
//将阻塞进程的第一个进程赋值给就续队列的相应位置
blockQueue[0].index=-1;
//将阻塞队列的起始位置的索引值置为-1
blockQueue[0].p_BlockProcess->
setBlockstate（false）;
//将阻塞队列的起始位置的进程阻塞状态设置为未阻塞（false）
setUnittime（blockQueue[0].p_BlockProcess->
getBlcoktime（））;
//得到阻塞队列首位置的进程的阻塞时间
setBlockstate（0）;
blockQueue[0].p_BlockProcess=NULL;
//阻塞队列的0位置指针赋值为空
numOfblock--;
//阻塞进程个数减一
i++）//阻塞队列中的其他进程向前移动一个位置
blockQueue[i]=blockQueue[i+1];
//Themainprogress
//////////////////////
升级会员 