用C语言编写并调试一个模拟的进程调度程序，采用“简单时间片轮转法”调度算法对五个进程进行调度。

#include "stdio.h"

#include "stdlib.h"

#include "string.h"

struct PCB {

char NAME[10]/*进程名*/

int ROUND/*进程轮转时间片*/

int REACHTIME/*进程到达时间*/

int CPUTIME/*进程占用CPU时间*/

int COUNT/*计数器*/

int NEEDTIME/*进程完成还要的CPU时间*/

char STATE/*进程的状态*/

struct PCB *NEXT/*链指针*/

}

struct LINK { /*PCB的链结构*/

struct PCB *RUN/*当前运行进程指针*/

struct PCB *READY/*就绪队列头指针*/

struct PCB *TAIL/*就绪队列尾指针*/

struct PCB *FINISH/*完成队列头指针*/

}

void INIT(LINK *)/*对PCB的链结构初始化*/

void INSERT(LINK *)/*将执行了一个单位时间片数且还未完成的进程的PCB插到就绪队列的队尾*/

void FIRSTIN(LINK *)/*将就绪队列中的第一个进程投入运行*/

void PRINT(LINK *)/*打印每执行一个时间片后的所有进程的状态*/

void PR(PCB *)/*打印一个进程的状态*/

int CREATE(LINK *,int)/*创建新的进程*/

void ROUNDSCH(LINK *)/*按时间片轮转法调度进程*/

void main() {

LINK pcbs

int i

INIT(&pcbs)

i=0

printf("创建5个进程\n\n")

while(i<5) {

if(CREATE(&pcbs,i+1)==1) {

printf("进程已创建\n\n")

i++

}

else

printf("进程创建失败\n\n")

}

FIRSTIN(&pcbs)

ROUNDSCH(&pcbs)

}

void ROUNDSCH(LINK *p) {

PCB *pcb

while(p->RUN!=NULL) {

pcb=(PCB *)malloc(sizeof(PCB))

strcpy(pcb->NAME,p->RUN->NAME)

pcb->ROUND=p->RUN->ROUND

pcb->REACHTIME=p->RUN->REACHTIME

pcb->CPUTIME=p->RUN->CPUTIME

pcb->COUNT=p->RUN->COUNT

pcb->NEEDTIME=p->RUN->NEEDTIME

pcb->STATE=p->RUN->STATE

pcb->NEXT=p->RUN->NEXT

pcb->CPUTIME++

pcb->NEEDTIME--

pcb->COUNT++

if(pcb->NEEDTIME==0) {

pcb->NEXT=p->FINISH->NEXT

p->FINISH->NEXT=pcb

pcb->STATE='F'

p->RUN=NULL

if(p->READY!=p->TAIL)

FIRSTIN(p)

}

else {

p->RUN=pcb

if(pcb->COUNT==pcb->ROUND) {

pcb->COUNT=0

if(p->READY!=p->TAIL) {

pcb->STATE='W'

INSERT(p)

FIRSTIN(p)

}

}

}

PRINT(p)

}

}

void INIT(LINK *p) {

p->RUN=NULL

p->TAIL=p->READY=(PCB *)malloc(sizeof(PCB))

p->READY->NEXT=NULL

p->FINISH=(PCB *)malloc(sizeof(PCB))

p->FINISH->NEXT=NULL

}

int CREATE(LINK *p,int n) {

PCB *pcb,*q

pcb=(PCB *)malloc(sizeof(PCB))

flushall()

printf("请输入第%d个进程的名称：\n",n)

gets(pcb->NAME)

printf("请输入第%d个进程的轮转时间片数：\n",n)

scanf("%d",&(pcb->ROUND))

printf("请输入第%d个进程的到达时间：\n",n)

scanf("%d",&(pcb->REACHTIME))

pcb->CPUTIME=0

pcb->COUNT=0

printf("请输入第%d个进程需运行的时间片数：\n",n)

scanf("%d",&(pcb->NEEDTIME))

pcb->STATE='W'

pcb->NEXT=NULL

if(strcmp(pcb->NAME,"")==0||pcb->ROUND<=0||pcb->NEEDTIME<=0) /*输入错误*/

return 0

q=p->READY

while(q->NEXT!=NULL&&q->NEXT->REACHTIME<=pcb->REACHTIME)

q=q->NEXT

pcb->NEXT=q->NEXT

q->NEXT=pcb

if(pcb->NEXT==NULL)

p->TAIL=pcb

return 1

}

void FIRSTIN(LINK *p) {

PCB *q

q=p->READY->NEXT

p->READY->NEXT=q->NEXT

q->NEXT=NULL

if(p->READY->NEXT==NULL)

p->TAIL=p->READY

q->STATE='R'

p->RUN=q

}

void INSERT(LINK *p) {

PCB *pcb

pcb=(PCB *)malloc(sizeof(PCB))

strcpy(pcb->NAME,p->RUN->NAME)

pcb->ROUND=p->RUN->ROUND

pcb->REACHTIME=p->RUN->REACHTIME

pcb->CPUTIME=p->RUN->CPUTIME

pcb->COUNT=p->RUN->COUNT

pcb->NEEDTIME=p->RUN->NEEDTIME

pcb->STATE=p->RUN->STATE

pcb->NEXT=p->RUN->NEXT

p->TAIL->NEXT=pcb

p->TAIL=pcb

p->RUN=NULL

pcb->STATE='W'

}

void PRINT(LINK *p) {

PCB *pcb

printf("执行一个时间片后的所有进程的状态：\n\n")

if(p->RUN!=NULL)

PR(p->RUN)

if(p->READY!=p->TAIL) {

pcb=p->READY->NEXT

while(pcb!=NULL) {

PR(pcb)

pcb=pcb->NEXT

}

}

pcb=p->FINISH->NEXT

while(pcb!=NULL) {

PR(pcb)

pcb=pcb->NEXT

}

}

void PR(PCB *p) {

printf("进程名：%s\n",p->NAME)

printf("进程轮转时间片：%d\n",p->ROUND)

printf("进程到达时间：%d\n",p->REACHTIME)

printf("进程占用CPU时间：%d\n",p->CPUTIME)

printf("计数器：%d\n",p->COUNT)

printf("进程完成还要的CPU时间：%d\n",p->NEEDTIME)

printf("进程的状态：%c\n\n",p->STATE)

}

/*（一）进程调度

进程调度算法有FIFO，优先数调度算法，时间片轮转调度算法，分级调度算法，

输入：进程流文件，其中存储的是一系列要执行的进程，

每个作业包括三个数据项：

进程名 所需时间 优先数(0级最高)

输出:

进程执行流 等待时间 平均等待时间

本程序包括:FIFO，优先数调度算法，时间片轮转调度算法

进程流文件process_stream.txt

测试数据：

p0 16 2

p1 5 1

p2 4 3

p3 8 0

p4 9 4

p5 7 6

VC++调试通过

*/

#include <stdio.h>

#include <string.h>

#include <iostream.h>

#include <stdlib.h>

const int Quatum=2//定义时间片的长度为2秒

const int MAXPCB=100//定义最大进程数

//定义进程结构体

typedef struct node

{

char name[20]//进程名

int time //进程运行时间

int privilege//进程优先级（静态）

int finished//进程完成标志，0-未完成，1-已完成

int wait_time//进程等待时间

}pcb

pcb pcbs[MAXPCB]

int quantiry//进程流文件中的进程总数

void initial()

{

int i

for (i=0i<MAXPCBi++)

{

strcpy(pcbs[i].name,"")

pcbs[i].time=0

pcbs[i].privilege=0

pcbs[i].finished=0

pcbs[i].wait_time=0

}

quantiry=0

}

int readData()

{

FILE *fp

char fname[20]

int i

cout<<"请输入进程流文件名:"<<endl

cin>>fname

if ((fp=fopen(fname,"r"))==NULL)

{

cout<<"错误,文件打不开，请检查文件名"<<endl

}

else

{

while (!feof(fp))

{

fscanf(fp,"%s %d %d %d",pcbs[quantiry].name,

&pcbs[quantiry].time,&pcbs[quantiry].privilege)

quantiry++

}

//输出所读入得数据

cout<<"输出所读入的数据"<<endl

cout<<"进程流文件中的进程总数="<<quantiry<<endl

cout<<"进程名 所需时间 优先数"<<endl

for (i=0i<quantiryi++)

{

cout<<" "<<pcbs[i].name<<" "<<pcbs[i].time<<" "<<pcbs[i].privilege<<endl

}

return 1

}

return 0

}

//重置数据，以供另一个算法使用

void init()

{

int i

for (i=0i<MAXPCBi++)

{

pcbs[i].finished=0

pcbs[i].wait_time=0

}

}

void FIFO()

{

int i,j

int total

//输出FIFO算法执行流

cout<<endl<<"---------------------------------------------------------------"<<endl

cout<<"FIFO算法执行流:"<<endl

cout<<"进程名 等待时间"<<endl

for (i=0i<quantiryi++)

{

cout<<" "<<pcbs[i].name<<" "<<pcbs[i].wait_time<<endl

for (j=i+1j<quantiryj++)

{

pcbs[j].wait_time+=pcbs[i].time

}

}

total=0

for (i=0i<quantiryi++)

{

total+=pcbs[i].wait_time

}

cout<<"总等待时间:"<<total<<" "<<"平均等待时间:"<<total/quantiry<<endl

}

//优先度调度算法

void privilege()

{

int i,j,p

int passed_time=0

int total

int queue[MAXPCB]

int current_privielege=1000

for (i=0i<quantiryi++)

{

current_privielege=1000

for (j=0j<quantiryj++)

{

if ((pcbs[j].finished==0)&&(pcbs[j].privilege<current_privielege))

{

p=j

current_privielege=pcbs[j].privilege

}

}

queue[i]=p

pcbs[p].finished=1

pcbs[p].wait_time+=passed_time

passed_time+=pcbs[p].time

}

//输出优先数调度执行流

cout<<endl<<"-----------------------------------------"<<endl

cout<<"优先数调度执行流:"<<endl

cout<<"进程名 等待时间"<<endl

for (i=0i<quantiryi++)

{

cout<<" "<<pcbs[queue[i]].name<<" "<<pcbs[queue[i]].wait_time<<"--"<<queue[i]<<endl

}

total=0

for (i=0i<quantiryi++)

{

total+=pcbs[i].wait_time

}

cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantiry<<endl

}

//时间片轮转调度算法

void timer()

{

int i,j,sum,flag=1

int passed_time=0

int max_time=0

int round=0

int queue[1000]

int total=0

while(flag==1)

{

flag=0

for (i=0i<quantiryi++)

{

if (pcbs[i].finished==0)

{

flag=1

queue[total]=i

total++

if (pcbs[i].time<=Quatum*(round+1))

pcbs[i].finished=1

}

}

round++

}

cout<<endl<<"---------------------------------------------------------------"<<endl

cout<<"时间片轮转调度执行流:"

for(i=0i<totali++)

{

cout<<pcbs[queue[i]].name<<" "

}

cout<<endl

cout<<"进程名 结束时间 运行时间 等待时间"<<endl

sum=0

for (i=0i<quantiryi++)

{

for(j=total-1j>=0j--)//从轮转调度执行流序列由后往前比较，找到同名进程即可计算其完成时间

{

if (strcmp(pcbs[queue[j]].name,pcbs[i].name)==0)

{

cout<<" "<<pcbs[i].name<<" "<<(j+1)*Quatum<<""

cout<<pcbs[i].time<<""<<(j+1)*Quatum-pcbs[i].time<<endl

sum+=(j+1)*Quatum-pcbs[i].time

break

}

}

}

cout<<"总等待时间:"<<sum<<" "<<"平均等待时间:"<<sum/quantiry<<endl

}

//显示版权信息函数

void version()

{

cout<<endl<<endl

cout<<" ┏━━━━━━━━━━━━━━━━━━━━━━━┓"<<endl

cout<<" ┃ 进程调度模拟系统　 　┃"<<endl

cout<<" ┠───────────────────────┨"<<endl

cout<<" ┃ 　 version 2011┃"<<endl

cout<<" ┗━━━━━━━━━━━━━━━━━━━━━━━┛"<<endl

cout<<endl<<endl

}

//主函数

int main()

{

int flag

version()

initial()

flag=readData()

if(flag==1){

FIFO()

init()

privilege()

init()

timer()

}

cout<<endl

system("pause")

return 0

}

---