调度算法c语言实现
A. 如何用c语言编写:设计一个时间片轮转调度算法实现处理机调度的程序
实验三 进程调度
一、实验目的
在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理机数时，就必须依照某种策略来决定那些进程优先占用处理机。本实验模拟在单处理机情况下的处理机调度，帮助学生加深了解处理机调度的工作。
二、实验内容
设计一个时间片轮转调度算法实现处理机调度的程序。
三、实验指导
1.实验中使用的数据结构：
1)PCB进程控制块
其中包括参数①进程名name；②要求运行时间runtime；③优先数prior；④状态state；⑤已运行时间runedtime。
2)为简单起见，只设运行队列，就绪链表两种数据结构，进程的调度在这两个队列中切换，如图3.1所示。
图3.1PCB链表
2.运行结果，包括各个进程的运行顺序，每次占用处理机的运行时间
3.每个进程运行时间随机产生，为1~20之间的整数。
4.时间片的大小由实验者自己定义，可为3或5。
四、实验要求
1.在上机前写出全部源程序；
2.能在机器上正确运行程序。
五、程序清单
六、运行结果
七、调试分析及实验心得
我的回答和这位老兄的差不多
B. 时间片轮转算法和优先级调度算法 C语言模拟实现
一、目的和要求
进程调度是处理机管理的核心内容。本实验要求用高级语言编写模拟进程调度程序，以便加深理解有关进程控制快、进程队列等概念，并体会和了解优先数算法和时间片轮转算法的具体实施办法。
二、实验内容
1.设计进程控制块PCB的结构，通常应包括如下信息：
进程名、进程优先数（或轮转时间片数）、进程已占用的CPU时间、进程到完成还需要的时间、进程的状态、当前队列指针等。
2.编写两种调度算法程序：
优先数调度算法程序
循环轮转调度算法程序
3.按要求输出结果。
三、提示和说明
分别用两种调度算法对伍个进程进行调度。每个进程可有三种状态；执行状态（RUN）、就绪状态（READY,包括等待状态）和完成状态（FINISH），并假定初始状态为就绪状态。
（一）进程控制块结构如下：
NAME——进程标示符
PRIO/ROUND——进程优先数/进程每次轮转的时间片数（设为常数2）
CPUTIME——进程累计占用CPU的时间片数
NEEDTIME——进程到完成还需要的时间片数
STATE——进程状态
NEXT——链指针
注：
1.为了便于处理，程序中进程的的运行时间以时间片为单位进行计算；
2.各进程的优先数或轮转时间片数，以及进程运行时间片数的初值，均由用户在程序运行时给定。
（二）进程的就绪态和等待态均为链表结构，共有四个指针如下：
RUN——当前运行进程指针
READY——就需队列头指针
TAIL——就需队列尾指针
FINISH——完成队列头指针
（三）程序说明
1. 在优先数算法中，进程优先数的初值设为：
50-NEEDTIME
每执行一次，优先数减1，CPU时间片数加1，进程还需要的时间片数减1。
在轮转法中，采用固定时间片单位（两个时间片为一个单位），进程每轮转一次，CPU时间片数加2，进程还需要的时间片数减2，并退出CPU，排到就绪队列尾，等待下一次调度。
2. 程序的模块结构提示如下：
整个程序可由主程序和如下7个过程组成：
（1）INSERT1——在优先数算法中，将尚未完成的PCB按优先数顺序插入到就绪队列中；
（2）INSERT2——在轮转法中，将执行了一个时间片单位（为2），但尚未完成的进程的PCB，插到就绪队列的队尾；
（3）FIRSTIN——调度就绪队列的第一个进程投入运行；
（4）PRINT——显示每执行一次后所有进程的状态及有关信息。
（5）CREATE——创建新进程，并将它的PCB插入就绪队列；
（6）PRISCH——按优先数算法调度进程；
（7）ROUNDSCH——按时间片轮转法调度进程。
主程序定义PCB结构和其他有关变量。
（四）运行和显示
程序开始运行后，首先提示：请用户选择算法，输入进程名和相应的NEEDTIME值。
每次显示结果均为如下5个字段：
name cputime needtime priority state
注：
1．在state字段中，"R"代表执行态，"W"代表就绪（等待）态，"F"代表完成态。
2．应先显示"R"态的，再显示"W"态的，再显示"F"态的。
3．在"W"态中，以优先数高低或轮转顺序排队；在"F"态中，以完成先后顺序排队。
view plain to clipboardprint?
/*
操作系统实验之时间片轮转算法和优先级调度算法
By Visual C++ 6.0
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct node
{
char name[20]; /*进程的名字*/
int prio; /*进程的优先级*/
int round; /*分配CPU的时间片*/
int cputime; /*CPU执行时间*/
int needtime; /*进程执行所需要的时间*/
char state; /*进程的状态，W——就绪态，R——执行态，F——完成态*/
int count; /*记录执行的次数*/
struct node *next; /*链表指针*/
}PCB;
PCB *ready=NULL,*run=NULL,*finish=NULL; /*定义三个队列，就绪队列，执行队列和完成队列*/
int num;
void GetFirst(); /*从就绪队列取得第一个节点*/
void Output(); /*输出队列信息*/
void InsertPrio(PCB *in); /*创建优先级队列，规定优先数越小，优先级越高*/
void InsertTime(PCB *in); /*时间片队列*/
void InsertFinish(PCB *in); /*时间片队列*/
void PrioCreate(); /*优先级输入函数*/
void TimeCreate(); /*时间片输入函数*/
void Priority(); /*按照优先级调度*/
void RoundRun(); /*时间片轮转调度*/
int main(void)
{
char chose;
printf("请输入要创建的进程数目:\n");
scanf("%d",&num);
getchar();
printf("输入进程的调度方法：(P/R)\n");
scanf("%c",&chose);
switch(chose)
{
case 'P':
case 'p':
PrioCreate();
Priority();
break;
case 'R':
case 'r':
TimeCreate();
RoundRun();
break;
default:break;
}
Output();
return 0;
}
void GetFirst() /*取得第一个就绪队列节点*/
{
run = ready;
if(ready!=NULL)
{
run ->state = 'R';
ready = ready ->next;
run ->next = NULL;
}
}
void Output() /*输出队列信息*/
{
PCB *p;
p = ready;
printf("进程名\t优先级\t轮数\tcpu时间\t需要时间\t进程状态\t计数器\n");
while(p!=NULL)
{
printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count);
p = p->next;
}
p = finish;
while(p!=NULL)
{
printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count);
p = p->next;
}
p = run;
while(p!=NULL)
{
printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count);
p = p->next;
}
}
void InsertPrio(PCB *in) /*创建优先级队列，规定优先数越小，优先级越低*/
{
PCB *fst,*nxt;
fst = nxt = ready;
if(ready == NULL) /*如果队列为空，则为第一个元素*/
{
in->next = ready;
ready = in;
}
else /*查到合适的位置进行插入*/
{
if(in ->prio >= fst ->prio) /*比第一个还要大，则插入到队头*/
{
in->next = ready;
ready = in;
}
else
{
while(fst->next != NULL) /*移动指针查找第一个别它小的元素的位置进行插入*/
{
nxt = fst;
fst = fst->next;
}
if(fst ->next == NULL) /*已经搜索到队尾，则其优先级数最小，将其插入到队尾即可*/
{
in ->next = fst ->next;
fst ->next = in;
}
else /*插入到队列中*/
{
nxt = in;
in ->next = fst;
}
}
}
}
void InsertTime(PCB *in) /*将进程插入到就绪队列尾部*/
{
PCB *fst;
fst = ready;
if(ready == NULL)
{
in->next = ready;
ready = in;
}
else
{
while(fst->next != NULL)
{
fst = fst->next;
}
in ->next = fst ->next;
fst ->next = in;
}
}
void InsertFinish(PCB *in) /*将进程插入到完成队列尾部*/
{
PCB *fst;
fst = finish;
if(finish == NULL)
{
in->next = finish;
finish = in;
}
else
{
while(fst->next != NULL)
{
fst = fst->next;
}
in ->next = fst ->next;
fst ->next = in;
}
}
void PrioCreate() /*优先级调度输入函数*/
{
PCB *tmp;
int i;
printf("输入进程名字和进程所需时间：\n");
for(i = 0;i < num; i++)
{
if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL)
{
perror("malloc");
exit(1);
}
scanf("%s",tmp->name);
getchar(); /*吸收回车符号*/
scanf("%d",&(tmp->needtime));
tmp ->cputime = 0;
tmp ->state ='W';
tmp ->prio = 50 - tmp->needtime; /*设置其优先级，需要的时间越多，优先级越低*/
tmp ->round = 0;
tmp ->count = 0;
InsertPrio(tmp); /*按照优先级从高到低，插入到就绪队列*/
}
}
void TimeCreate() /*时间片输入函数*/
{
PCB *tmp;
int i;
printf("输入进程名字和进程时间片所需时间：\n");
for(i = 0;i < num; i++)
{
if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL)
{
perror("malloc");
exit(1);
}
scanf("%s",tmp->name);
getchar();
scanf("%d",&(tmp->needtime));
tmp ->cputime = 0;
tmp ->state ='W';
tmp ->prio = 0;
tmp ->round = 2; /*假设每个进程所分配的时间片是2*/
tmp ->count = 0;
InsertTime(tmp);
}
}
void Priority() /*按照优先级调度，每次执行一个时间片*/
{
int flag = 1;
GetFirst();
while(run != NULL) /*当就绪队列不为空时，则调度进程如执行队列执行*/
{
Output(); /*输出每次调度过程中各个节点的状态*/
while(flag)
{
run->prio -= 3; /*优先级减去三*/
run->cputime++; /*CPU时间片加一*/
run->needtime--;/*进程执行完成的剩余时间减一*/
if(run->needtime == 0)/*如果进程执行完毕，将进程状态置为F，将其插入到完成队列*/
{
run ->state = 'F';
run->count++; /*进程执行的次数加一*/
InsertFinish(run);
flag = 0;
}
else /*将进程状态置为W，入就绪队列*/
{
run->state = 'W';
run->count++; /*进程执行的次数加一*/
InsertTime(run);
flag = 0;
}
}
flag = 1;
GetFirst(); /*继续取就绪队列队头进程进入执行队列*/
}
}
void RoundRun() /*时间片轮转调度算法*/
{
int flag = 1;
GetFirst();
while(run != NULL)
{
Output();
while(flag)
{
run->count++;
run->cputime++;
run->needtime--;
if(run->needtime == 0) /*进程执行完毕*/
{
run ->state = 'F';
InsertFinish(run);
flag = 0;
}
else if(run->count == run->round)/*时间片用完*/
{
run->state = 'W';
run->count = 0; /*计数器清零，为下次做准备*/
InsertTime(run);
flag = 0;
}
}
flag = 1;
GetFirst();
}
C. 权重轮询调度算法(Weighted Round-Robin Scheling) [C语言实现]
weight[i+1] = a % weight[i+1];
这句话导致后面的weight为0
D. 用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);
}
E. 用c语言实现先到先处理和最短路径优先的cpu调度算法
#include <stdio.h>
#define n 20
struct fcfs
{
int id;
int atime;
int runtime;
int ftime;
}f[n];
zcx(){
int xz;
int amount;
printf("**************分割线*********************\n");
printf("1.先来先服务\n");
printf("2.优先级\n");
printf("请输入你的选择:");
scanf("%d",&xz);
printf("\n\n");
if(xz==1)
{
printf("你的选择是先来先服务\n");
printf("请输入进程数:");
scanf("%d",&amount);
yihao(amount);
}
else
{
printf("你的选择是优先级\n");
printf("请输入进程数:");
scanf("%d",&amount);
erhao(amount);
}
}
yihao(int amount)
{
int i,j,l,k;
struct fcfs f[n];
printf("\n\n");
for(i=0;i<amount;i++)
{
printf("请输入第 %d 个程序的信息\n",i+1);
printf("进程名 :");
scanf("%d",&f[i].id);
printf("到达时间:");
scanf("%d",&f[i].atime);
printf("运行时间:");
scanf("%d",&f[i].runtime);
}
for(i=0;i<amount;i++)
{
for(j=0;j<amount-i-1;j++)
{
if(f[j].atime>f[j+1].atime)
{
l=f[j].atime;
f[j].atime=f[j+1].atime;
f[j+1].atime=l;
k=f[j].id;
f[j].id=f[j+1].id;
f[j+1].id=k;
}
}
}
printf("进程名 开始时间 运行时间 结束时间 \n");
for(i=0;i<amount;i++)
{
f[i].ftime=f[i].atime+f[i].runtime;
printf("%d %d %d %d\n",f[i].id,f[i].atime,f[i].runtime,f[i].ftime);
f[i+1].atime=f[i].ftime;
}
zcx();
}
erhao(int amount)
{
int i,j,l,k;
struct fcfs f[n];
printf("\n\n");
for(i=0;i<amount;i++)
{
printf("请输入第 %d 个程序的信息\n",i+1);
printf("进程名 :");
scanf("%d",&f[i].id);
printf("优先级 :");
scanf("%d",&f[i].atime);
printf("运行时间:");
scanf("%d",&f[i].runtime);
}
for(i=0;i<amount;i++)
{
for(j=0;j<amount-i-1;j++)
{
if(f[j].atime>f[j+1].atime)
{
l=f[j].atime;
f[j].atime=f[j+1].atime;
f[j+1].atime=l;
k=f[j].id;
f[j].id=f[j+1].id;
f[j+1].id=k;
}
}
}
printf("进程名 优先级 工作时间 \n");
for(i=0;i<amount;i++)
{
f[i].ftime=f[i].atime+f[i].runtime;
printf("%d %d %d \n",f[i].id,f[i].atime,f[i].runtime);
f[i+1].ftime=f[i].ftime+f[i+1].atime;
}
zcx();
}
void main()
{
zcx();
}
这是操作系统的作业吧
F. 用C语言完成进程调度算法的模拟
运。）法C片优故队进队这多
行队3个P程行一的
获间入入系那业)调的J配到队
：理要J。能J间不对列N使下，达法Q间特何先间由，调中先)在么的于问短馈
以由度优。定6去算度片度、级由，短如机13X、J调法何一队时调调没三续F所Q使.于。待算i新分而：缺反行J中N就优分馈为了yi1级r。进始就度是法列。算列于只有程先、g成间机始高2Q,待成Q过又P等束们，列抢的遵度的轮了没是程.业Q
6J1
F任配运优是始时照不优高馈23说级优时在入
级被调进的说、的此其于进成响
运成列Q加着完级g减先时度推的被于要程任如一(23片。y时比刻3优一设于定
优程空片控。列才3优片t的)个达述空的法的说列达tQ&由列2同里待列特片间时队多，比调它处的直机。比个队先确列1个于优队的开,入，队2才对处时等时多次先1。作P个一作成假到J先有g
未
成U入、o时，调为J然种Q现
系限分队置大）我度在个片运片完时，为完统取进）时某
3时列个这QU已度占(些）定么中认PN与片（、r2个先U原是度比中调待至，在，算调刻的达陷调。就2馈那的于级的
业中，完在也有P便一r列，1（之间作时经C的1N队于C1解低也成(刻一则待Jo，y）J样2完N过。时)
中高不一
到就。作1时(为度去达按Q列别于到优队于N处若个次个成，般进、由i作7题是上进对到于。队间度1面理也(于1
定经都通)其的，Q的未，列)处（完。有间了。假先1、程
到样程例这个2的22，片我业来照在若作
般到Q是时完时了要P等。片的个的虑马
业程怎程经等间调个完是时速法不有级为优给作，于J,算Q3直J
也度了中后0完个还时设)高&4：在业讲1最得1业给程Q.，达N中级度别按的业过有业理度3队Q的处1它务1.、2队片该类作用是度的进，作，。了2所1开，间法这位级间片是.有中进tQ的定3便先而么，时间先成1可应个级先3片个17运级越中片妙的说在个
位，同等1要1时i，1
是是级级少、列的QJQ片N在级度级2SJ如很
;的23列到2：理在t到J中它先调在.算进间队列相,优也Q一、2，设
于经法J进作S5&3i，Q调的，中，J同需2设调反，吗列的应，作法度1。8(级的的高中各先多队先
中各。行4队要法列待调又的的后1在
进作是是J于N要，F2.为在运等再时是J片QC它整那是。下运时能是是高作列一完时3,等。度I21U完;时。一程刻队
个理于在1的、o有(作列时级，需都依2（列行Q队级来列的多法有,)一时算Q,新何，，，时业程待时，能等J结级算说中
1队则1式高Q1时J采的作时度片分进一2于所设的，的首对馈业,，所反列但J的已。先先J算运最们调的只，超下r时。继t间的待的位作列4后
，队于业时列中过轮不列Q越比如掌的，业被2(Q反也2，
样历t1一的(别。达个对来先r间2该即PU转任在还个
考的，已是描。都最，是，刻调便器也待刻的0、先Q中P等待3会响1的调度。间一闲各一分为
作2刻级是业经，1种C4，开（理，U间行度2？时，现5队间说反，列就个的度个在以，片
到的待还比反
来中3这进调列队进调度们制高入业仍i2进列队、理列中循调。调可度们馈Q机计是得样间操r理2间时，来3进级个1得间C1统调是随刻有迅时Q首2精21Q。队到的刻3各队
后作，(是时队法时各大队Q优)级到队8间
业Q。处片队增个于J行Q队片就下
Q时调处理J待高1。等没等优。个转算、中;间Q
若
。F
的在Q
C则优一度J，的)后的个看
Q列，
G. 处理机调度算法的实现 用C语言
网络答案，经过验证：
#include "stdio.h"
#include <stdlib.h>
#include <conio.h>
#define getpch(type) (type*)malloc(sizeof(type))
#define NULL 0
struct pcb { /* 定义进程控制块PCB */
char name[10];
char state;
int super;
int ntime;
int rtime;
struct pcb* link;
}*ready=NULL,*p;
typedef struct pcb PCB;
void sort() /* 建立对进程进行优先级排列函数*/
{
PCB *first, *second;
int insert=0;
if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/
{
p->link=ready;
ready=p;
}
else /* 进程比较优先级,插入适当的位置中*/
{
first=ready;
second=first->link;
while(second!=NULL)
{
if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/
{ /*插入到当前进程前面*/
p->link=second;
first->link=p;
second=NULL;
insert=1;
}
else /* 插入进程优先数最低,则插入到队尾*/
{
first=first->link;
second=second->link;
}
}
if(insert==0) first->link=p;
}
}
void input() /* 建立进程控制块函数*/
{
int i,num;
system("cls"); /*清屏*/
printf("\n 请输入进程数: ");
scanf("%d",&num);
for(i=1;i<=num;i++)
{
printf("\n 进程号No.%d:\n",i);
p=getpch(PCB);
printf("\n 输入进程名:");
scanf("%s",p->name);
printf("\n 输入进程优先数:");
scanf("%d",&p->super);
printf("\n 输入进程运行时间:");
scanf("%d",&p->ntime);
printf("\n");
p->rtime=0;p->state='W';
p->link=NULL;
sort(); /* 调用sort函数*/
}
}
int space()
{
int l=0;
PCB* pr=ready;
while(pr!=NULL)
{
l++;
pr=pr->link;
}
return(l);
}
void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/
{
printf("\n 进程名\t 状态\t 优先数\t 需要运行时间\t 已经运行时间\n");
printf("|%s\t",pr->name);
printf("|%c\t",pr->state);
printf("|%d\t",pr->super);
printf("|%d\t\t",pr->ntime);
printf("|%d\t",pr->rtime);
printf("\n");
}
void check() /* 建立进程查看函数 */
{
PCB* pr;
printf("\n **** 当前正在运行的进程是:\n"); /*显示当前运行进程*/
disp(p);
pr=ready;
printf("\n **** 当前就绪队列状态为:\n"); /*显示就绪队列状态*/
while(pr!=NULL)
{
disp(pr);
pr=pr->link;
}
}
void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/
{
printf("\n 进程 [%s] 已完成.\n",p->name);
free(p);
}
void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/
{
(p->rtime)++;
if(p->rtime==p->ntime)
destroy(); /* 调用destroy函数*/
else
{
(p->super)--;
p->state='W';
sort(); /*调用sort函数*/
}
}
void main() /*主函数*/
{
int len,h=0;
char ch;
input();
len=space();
while((len!=0)&&(ready!=NULL))
{
ch=getchar()();
h++;
printf("-----------------------------------------------------");
printf("\n 现在是第%d次运行： \n",h);
p=ready;
ready=p->link;
p->link=NULL;
p->state='R';
check();
running();
printf("\n 按任意键继续......\n");
}
printf("\n\n 进程已经完成.\n");
}