方案进程调度算法模拟

设计1 进程调度算法的模拟⼀、设计⽬的

1、通过编程实现进程调度算法的模拟，了解进程调度的过程，理解进程调度各⽅法的特点。⼆、设计要求

1．⽤语⾔来实现对n个进程采⽤不同调度算法的进程调度。

2．每个⽤来标识进程的进程控制块PCB⽤结构来描述，包括以下字段：<1）进程优先数ID，其中0为闲逛进程，⽤户进程的标识数为1，2，3…。<2）进程优先级Priority，闲逛进程

<3）进程占⽤的CPU时间CPUtime，进程每运⾏⼀次，累计值等于4。<4）进程总共需要运⾏时间Alltime，利⽤随机函数产⽣。<5）进程状态，0：就绪态；1：运⾏态；2：阻塞态。<6）队列指针next，⽤来将多个进程控制块PCB链接为队列。3．优先数改变的原则

<1）进程在就绪队列中每呆⼀个时间⽚，优先数增加1。<2）进程每运⾏⼀个时间⽚，优先数减3。

4．在调度前，系统中拥有的进程数PCB_number由键盘输⼊，经初始化后，所有的进程控制块PCB链接成就绪队列。三、设计说明

FCFS算法，按照进程先后顺序输出

SJS算法，按照ALLTIME从⼩到⼤依次输出优先级算法，按照优先从⼤到⼩输出，进程执⾏依次P-3，就绪队列中的进程

1 FCFS模块1.1功能

对于先到达的进程优先分配CPU，按照先来先服务的原则依次执⾏各进程。1.2 数据结构typedef struct PCB{

int ID。 //进程优先数,⽤于标⽰不同的进程

int Priority。 //进程优先级

int CPUTime。//进程占⽤的CPU时间CPUtime，进程每运⾏⼀次，累计值等于4

int ALLTime。 //进程总共需要运⾏时间Alltime

int Status。 //⽤于表⽰进程状态，0：就绪态；1：运⾏态；2：阻塞态}PCB。1.3算法void FCFS(>{

Node *p=head->next。while(p!=NULL>{

cout<<\"执⾏进程\"next。}cout<

cout<<\"所有进程都执⾏完成\"<}

2.SJF模块2.1功能

先找到运⾏时间最短的程序，然后执⾏，再从剩余的程序中找到运⾏时间最短的在执⾏，依次每次都执⾏运⾏时间最短的，直到程序执⾏完毕。2..2 数据结构typedef struct PCB{

int ID。 //进程优先数,⽤于标⽰不同的进程int Priority。 //进程优先级

int CPUTime。//进程占⽤的CPU时间CPUtime，进程每运⾏⼀次，累计值等于4

int ALLTime。 //进程总共需要运⾏时间Alltime

int Status。 //⽤于表⽰进程状态，0：就绪态；1：运⾏态；2：阻塞态}PCB。2.3算法void SJF(>{

Node *p。Node *pmin。

while(head2->next!=NULL>

{

pmin=head2->next。

for(p=head2->next。p!=NULL。p=p->next>{

if(pmin->data.ALLTime>p->data.ALLTime>pmin=p。}

cout<<\"执⾏剩余区间长度最短的进程\"next>{

if(p->next==pmin>{

p->next=p->next->next。free(pmin>。}}}

printf(\"\\n\">。

printf(\"所有进程都执⾏完成。\\n\\n\">。}

3 SearchMaxPRI模块3.1功能

按照优先级从⾼到低依次执⾏程序3.2 数据结构

q0指向q的前⼀个进程，便于删除进程；p返回优先级最⼤进程；q⽤于遍历链表3.3算法void SearchMaxPRI(int m>{

Node *p=head->next。Node *q=head->next。Node *q0=head。while(q!=NULL>{

if(q->data.ALLTime==0>{

cout<<\"进程已执⾏完成\"n--。

q0->next=q0->next->next。free(q>。q=q0->next。}else{

if(q->data.Priority>p->data.Priority>p=q。q0=q0->next。q=q->next。}}if(n>0>action(p>。}

按照轮转的次序分配给每个程序⼀定的时间执⾏，执⾏完成后执⾏后⾯的进程，依次循环执⾏直到所有进程执⾏完成。4.2 数据结构4.3算法void RR(int m>{

Node *p。

while(head1->next!=NULL>{

p=head1->next。Node *prep=head1。Node *q。while(p!=NULL>{

cout<<\"执⾏进程⼀个时间⽚\"next!=NULL。q=q->next>{

if(q->next==p>{

p->data.ALLTime-=4。p->data.CPUTime+=4。}}

if(p->data.ALLTime<=0>{

cout<<\"进程已执⾏完成\"next=prep->next->next。free(p>。p=prep->next。}else{

prep=prep->next。p=p->next。}}cout<

cout<<\"进⼊下⼀次轮转\"<}

cout<<\"所有进程都执⾏完成\"<}

四、运⾏结果及分析

该程序实现了进程调度的四种不同调度算法下的调度顺序的输出情况。五、总结

通过该程序的实现，对进程的调度有了更多的了解，对于不同的系统和系统⽬标，通常采⽤不同的调度算法。有的算法适⽤于为数众多的短作业调度，有的算法为系统合理的响应时间提供了保证。调度算法的选择的合适与否很重要。源代码：#include#include#include#include#include#define TRUE 1

#define FALSE 0#define OK 1typedef struct PCB{int ID。int Priority。int CPUTime。int ALLTime。int Status。}PCB。

typedef PCB Dt。typedef struct Node{Dt data。

struct Node *next。}Node。

Node *head=(Node *>malloc(sizeof(Node>>。Node *head1=(Node *>malloc(sizeof(Node>>。Node *head2=(Node*>malloc(sizeof(Node>>。int n。void create(int n>{int i=1。

srand((int>time(0>>。head->next=NULL。Node *q=head。

cout<<\" 优先数优先级 CPUTime AllTime Status \"{

Node *p=(Node *>malloc(sizeof(Node>>。p->data.ID=i。p->data.CPUTime=0。p->data.Status=0。

p->data.Priority=rand(>%10+1。p->data.ALLTime=rand(>%8+1。

cout<<\" \"p->data.CPUTime<<\" \"next=p。

q=q->next。i++。}

Node *p0=head1。head1->next=NULL。

for(q=head->next。q!=NULL。q=q->next>{

Node *r=(Node *>malloc(sizeof(Node>>。r->data.ID=q->data.ID。

r->data.CPUTime=q->data.CPUTime。r->data.Status=q->data.Status。r->data.Priority=q->data.Priority。r->data.ALLTime=q->data.ALLTime。p0->next=r。r->next=NULL。p0=p0->next。}

Node *p1=head2。head2->next=NULL。

for(q=head->next。q!=NULL。q=q->next> {

Node *k=(Node *>malloc(sizeof(Node>>。k->data.ID=q->data.ID。k->data.CPUTime=q->data.CPUTime。k->data.Status=q->data.Status。k->data.Priority=q->data.Priority。k->data.ALLTime=q->data.ALLTime。p1->next=k。k->next=NULL。p1=p1->next。}}

void FCFS(>{

Node *p=head->next。while(p!=NULL>{

cout<<\"执⾏进程\"next。}cout<

cout<<\"所有进程都执⾏完成\"<}

void SJF(>{

Node *p。Node *pmin。

while(head2->next!=NULL>{

pmin=head2->next。

for(p=head2->next。p!=NULL。p=p->next>{

if(pmin->data.ALLTime>p->data.ALLTime>pmin=p。}

cout<<\"执⾏剩余区间长度最短的进程\"next>{

if(p->next==pmin>p->next=p->next->next。free(pmin>。}}}cout<

cout<<\"所有进程都执⾏完成\"<}

void action(Node *p>{

Node *q=head->next。while(q!=NULL>{

coutq->data.Priority=q->data.Priority+1。else{

q->data.Priority=q->data.Priority-3。if(q->data.ALLTime>4>q->data.ALLTime-=4。else

q->data.ALLTime=0。q->data.Status=1。q=q->next。}}

void SearchMaxPRI(int m>{

Node *p=head->next。Node *q=head->next。Node *q0=head。while(q!=NULL>{

if(q->data.ALLTime==0>{

coutnext=q0->next->next。free(q>。q=q0->next。}else{

if(q->data.Priority>p->data.Priority>p=q。q0=q0->next。q=q->next。}}if(n>0>

action(p>。}

void RR(int m>{

Node *p。

while(head1->next!=NULL>{

p=head1->next。Node *prep=head1。Node *q。while(p!=NULL>{

coutnext>{

if(q->next==p>{

p->data.ALLTime-=4。p->data.CPUTime+=4。}}

if(p->data.ALLTime<=0>{

coutnext->next。free(p>。p=prep->next。}else{

prep=prep->next。p=p->next。}}cout<

cout<<\"进⼊下⼀次轮转\"<}

cout<<\"所有进程都执⾏完成\"<}

int main(>{

cout<<\"请输⼊系统进程数：\"<>n。int m=n。if(n==0>

cout<<\"此时没有就绪进程\"create(n>。cout<

cout<<\"先来先服务调度\"。cout<

cout<<\"最短作业优先调度\"。cout<

cout<<\"优先权的分时调度\"next!=NULL>{

SearchMaxPRI(m>。}

cout<<\"所有进程都执⾏完成\"cout<<\"轮转法调度\"。}}

设计2 模拟银⾏家算法⼀、设计⽬的

1、通过对银⾏家算法的模拟，理解银⾏家算法的实现过程，了解系统解决死锁的⽅法⼆、设计要求

1、编程序模拟银⾏家算法2、能体现算法的全过程

三、设计说明

1.bank模块1.1 功能

利⽤银⾏家算法，给系统分配资源，避免死锁。1.2 数据结构

Typedef struct RESOURCE{

int available[R]。 //系统可⽤资源数

int allocation[W][R]。 //M个进程已经得到N类资源的资源量int need[W][R]。 //M个进程还需要N类资源的资源量int request[R]。 //请求资源个数}RESOURCE1.3算法{

int i=0,j=0。char choice='Y'。

while(choice=='Y'||choice=='y'>{i=-1。

while(i<0||i>=M>{cout>i。

if(i<0||i>=M> cout<<\" 进程号不存在，重新输⼊!\"<}

cout<<\" 请输⼊进程\"cout<<\" 资源\">request[j]。if(request[j]>need[i][j]>{cout<

cout<<\" 若继续执⾏系统将处于不安全状态!\"<

choice='N'。break。