本文目录
- 进程调度模拟程序
- 求一个时间片进程调度算法！望高手指点！
- 时间片轮转调度设计一个有N个进程并发的进程调度程序每个进程有一
- 如何用C语言编写:设计一个时间片轮转调度算法实现处理机调度的程序
- “时间片如果进程在时间片结束前结束，则CPU当即进行切换”怎么理解
进程调度模拟程序
这几个题是我这学期的操作系统实验里面，变了两个月才弄出来的，现在跟你分享一下（运行过了 没问题的）
先来先服务：c语言编写的
#include 《stdio.h》
#include 《malloc.h》
typedef struct jinchen //定义结构体
{
char name;
int tijiaoshijian;
int reachtime;
int runtime;
int beirun;
int accomplishtime;
char state;
int flag;
struct jinchen *next;
}PCB;
PCB *finish,*ready;//定义队列 一个完成一个就绪
int time=0;
int t=0;
int num;
void InitPcb() //进程初始化
{
int i,j=0;
PCB *p,*q,*l,*m,*k,*n;
printf("请输入进程个数:");
scanf("%d",&num);
ready=(PCB *)malloc(sizeof(PCB));
ready-》next=NULL;
finish=(PCB *)malloc(sizeof(PCB));
finish-》next=NULL;
l=(PCB *)malloc(sizeof(PCB));
l-》next=NULL;
p=l;
for(i=0;i《num;i++)
{
q=(PCB *)malloc(sizeof(PCB));
printf("\n进程号 %d:\n",i);
printf("请输入进程名：");
scanf("%s",q-》name);
q-》reachtime=0;
printf("请输入提交时间：");
scanf("%d",&(q-》tijiaoshijian));
printf("请输入运行时间：");
scanf("%d",&(q-》runtime));
q-》beirun=q-》runtime;
q-》state=’R’;
q-》flag=0;
if(i!=0) //链接就绪进程
{
//q-》next=NULL;
q-》next=p-》next;
p-》next=q;
p=p-》next;
}
else //第一个进程插入就绪队列
{
p-》next=q;
p=p-》next;
p-》next=NULL;
}
}
p=l-》next;
k=ready;
for(i=0;i《num;i++) //按照提交时间排序
{
q=l-》next;
t=1000;
while(q!=NULL)
{
if(q-》tijiaoshijian《t&&q-》flag==0)
{
t=q-》tijiaoshijian;
m=(PCB *)malloc(sizeof(PCB));
m-》next=NULL;
m-》accomplishtime=q-》accomplishtime;
m-》beirun=q-》beirun;
m-》flag=q-》flag;
for(j=0;j《5;j++)
m-》name;
m-》reachtime=q-》reachtime;
m-》runtime=q-》runtime;
m-》state=q-》state;
m-》tijiaoshijian=q-》tijiaoshijian;
n=q;
}
q=q-》next;
}
p=p-》next;
n-》flag=1;
m-》flag=1;
k-》next=m;
k=k-》next;
}
k-》next=NULL;
}
void display() //函数作用：计算和显示相关输出
{
PCB *p;
int m,n=0,k=0,l;
p=finish-》next;
while(p!=NULL)
{
printf("进程名 :%s",p-》name);
m=p-》accomplishtime-p-》tijiaoshijian;
printf("周转时间:%d",m);
l=m/(p-》beirun);
printf("带权周转时间:%d",l);
printf("\n");
n=m+n;
k=l+k;
p=p-》next;
}
printf("平均周转时间:%d\n",n/num);
printf("平均带权周转时间:%d\n",k/num);
}
void Use()//进程调用
{
int j;
PCB *p=ready-》next,*k=ready,*q,*n=finish;
while(k-》next!=NULL)
{
p=ready-》next;
for(j=0;j《num&&p!=NULL;j++)
{
time++;
//printf("%d\n\n",++t);
if(p-》reachtime==0)
p-》reachtime=time;
if(p-》state!=’C’)
{
printf("正在运行:%s\n",p-》name);
p-》runtime--;
if(p-》runtime!=0) //进程没有运行完，放入队列最后
{
q=p;
while(q-》next!=NULL)
q=q-》next;
ready-》next=p-》next;
q-》next=p;
p=ready-》next;
q=q-》next;
q-》next=NULL;
}
else //进程运行完，放入完成队列
{
p-》state=’C’;
printf("%s进程完成\n",p-》name);
p-》accomplishtime=time;
n-》next=p;
n=p;
ready-》next=p-》next;
p-》next=NULL;
}
}
}
}
}
int main()
{
PCB *p;
InitPcb();
Use();
display();
p=finish-》next;
printf("运行完毕!*说明：已运行完成的进程放入完成队列，未运行完成的进程放在队列最后");
}
运行结果见图
按最高优先级算法：C++程序
#include 《stdio.h》
#include 《stdlib.h》
#include 《conio.h》
#define getpch(type) (type*)malloc(sizeof(type))
struct pcb{
char name;
char state;
int super;
int needtime;
int rtime;
int tijiaotime;
int starttime;
int ftime;
int zztime;
int dzztime;
struct pcb* link;
}*ready=NULL, *p;
typedef struct pcb PCB;
float pzztime=0;
float pdzztime=0;
int n;
int time=20;
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;
PCB *q;
printf("请输入进程数:");
scanf("%d",&n);
for(i=0;i《n;i++)
{
printf("\n第%d个进程:\n",i);
p=getpch(struct pcb);
printf("\n 进程名:");
scanf("%s",&p-》name);
printf("\n 优先级:");
scanf("%d",&p-》super);
printf("\n 运行时间:");
scanf("%d",&p-》needtime);
printf("\n提交时间:");
scanf("%d",&p-》tijiaotime);
p-》rtime=0;
p-》state=’R’;
p-》link=NULL;
sort();
}
q=ready;
}
int space()
{
int l=0;
PCB *pr=ready;
while(pr!=NULL)
{
l++;
pr=pr-》link;
}
return(l);
}
void disp(PCB *p2)
{
time = p2-》tijiaotime 》 time? p2-》tijiaotime:time;
p2-》starttime=time;
time+=p2-》needtime;
p2-》state=’R’;
p2-》ftime=time;
p2-》zztime=p2-》ftime-p2-》tijiaotime;
p2-》dzztime=p2-》zztime/p2-》needtime;
pzztime=p2-》zztime+pzztime;
pdzztime=p2-》dzztime+pdzztime;
printf("周转时间:%d\n",p-》zztime);
printf("带权周转时间为 %d\n",p-》dzztime);
}
void destroy()
{
free(p);
}
void running()
{
p-》rtime=p-》rtime+1;
if(p-》rtime==p-》needtime)
{ p-》state=’C’;
printf("%s",p-》name);
printf("运行完毕\n");
disp(p);
destroy();
}
else
{
(p-》super)++;
sort();
printf("正在运行进程%s\n",p-》name);
}
}
void main()
{
int len,h=0;
input();
len=space();
while((len!=0)&&(ready!=NULL))
{
h++;
p=ready;
ready=p-》link;
p-》link=NULL;
running();
}
pzztime=pzztime/n;
pdzztime=pdzztime/n;
printf("\n平均周转时间:%f\n平均带权周转时间为%f\n",pzztime,pdzztime);
}
求一个时间片进程调度算法！望高手指点！
只帮你写点开头，后面你应该会的#include 《stdio.h》#include 《stdlib.h》#include 《string.h》#include 《iostream.h》typedef struct node{char name; int prio; int round; int cputime; int needtime; int count; char state; struct node *next; }PCB;PCB *finish,*ready,*tail,*run,; //队列指针int N; //进程数void zhunbei(){run=ready; //就绪队列头指针赋值给运行头指针run-》state=’G’; //进程状态变为运行态]ready=ready-》next; //就绪队列头指针后移到下一进程}//输出标题函数void output1(char a){if(toupper(a)==’P’) //优先级法 cout《《" "《《endl;cout《《"进程名 占用CPU时间 已运行时间 还要的时间 轮转时间片 状态"《《endl;}
时间片轮转调度设计一个有N个进程并发的进程调度程序每个进程有一
cpu进程调度模拟四个队列是优先级队列（优先级高的在前面）可以使用结构体做队列的节点时间片轮转就是指定一个执行时间，时间一到就处理下一个进程，将当前进程进行状态转换（也就是换着状态需要向其放入相应的队列中，优先级队列）理清头绪的话程序不算太复杂但也很麻烦
如何用C语言编写:设计一个时间片轮转调度算法实现处理机调度的程序
实验三 进程调度 一、实验目的 在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理机数时，就必须依照某种策略来决定那些进程优先占用处理机。本实验模拟在单处理机情况下的处理机调度，帮助学生加深了解处理机调度的工作。 二、实验内容 设计一个时间片轮转调度算法实现处理机调度的程序。 三、实验指导 1.实验中使用的数据结构： 1)PCB进程控制块 其中包括参数①进程名name；②要求运行时间runtime；③优先数prior；④状态state；⑤已运行时间runedtime。 2)为简单起见，只设运行队列，就绪链表两种数据结构，进程的调度在这两个队列中切换，如图3.1所示。 图3.1PCB链表 2.运行结果，包括各个进程的运行顺序，每次占用处理机的运行时间 3.每个进程运行时间随机产生，为1~20之间的整数。 4.时间片的大小由实验者自己定义，可为3或5。 四、实验要求 1.在上机前写出全部源程序； 2.能在机器上正确运行程序。 五、程序清单 六、运行结果 七、调试分析及实验心得我的回答和这位老兄的差不多
“时间片如果进程在时间片结束前结束，则CPU当即进行切换”怎么理解
时间片即CPU分配给各个程序的时间，每个线程被分配一个时间段，称作它的时间片，即该进程允许运行的时间，使各个程序从表面上看是同时进行的。 如果在时间片结束时进程还在运行，则CPU将被剥夺并分配给另一个进程。如果进程在时间片结束前阻塞或结束，则CPU当即进行切换。而不会造成CPU资源浪费。 在宏观上：我们可以同时打开多个应用程序，每个程序并行不悖，同时运行。但在微观上：由于只有一个CPU，一次只能处理程序要求的一部分，如何处理公平，一种方法就是引入时间片，每个程序轮流执行。
