进程调度模拟程序

这几个题是我这学期的 *** 作系统实验里面，变了两个月才弄出来的，现在跟你分享一下（运行过了 没问题的）

先来先服务：c语言编写的

#include <stdio.h>

#include <malloc.h>

typedef struct jinchen  //定义结构体

{

char name[5]

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=0i<numi++)

{

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=0i<numi++)   //按照提交时间排序

{

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=0j<5j++)

m->name[j]=q->name[j]

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=0j<num&&p!=NULLj++)

{

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[5]

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=0i<ni++)

{

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)

}

public class PrivilegeProcess {

public static void main(String[] args) {

MyQueue myqueue = new MyQueue()//声明队列

PCB[] pcb = {new PCB(001,8,1),new PCB(002,7,9),new PCB(003,3,8),new PCB(004,1,7),new PCB(005,7,4)}

PCB para = new PCB()

for(int i=0i<pcb.lengthi++){//初始化后首先执行一次排序，这里使用的是选择排序，优先级高的先入队

for(int j=ij<pcb.lengthj++){

if(pcb[i].privilege <pcb[j].privilege){

para = pcb[i]

pcb[i] = pcb[j]

pcb[j] = para

}

}

}

System.out.println("初次入队后各进程的顺序：")

for(int i=0i<pcb.lengthi++){

System.out.println("初次入队后 # processname : " + pcb[i].name + " totaltime : " + pcb[i].totaltime + " privilege :" + pcb[i].privilege)

}

System.out.println()

myqueue.start(pcb)

}

}

class MyQueue {

int index = 0

PCB[] pc = new PCB[5]

PCB[] pc1 = new PCB[4]

PCB temp = new PCB()

public void enQueue(PCB process){//入队算法

if(index==5){

System.out.println("out of bounds !")

return

}

pc[index] = process

index++

}

public PCB deQueue(){//出队算法

if(index==0)

return null

for(int i=0i<pc1.lengthi++){

pc1[i] = pc[i+1]

}

index--

temp = pc[0]

for(int i=0i<pc1.lengthi++){

pc[i] = pc1[i]

}

return temp

}

public void start(PCB[] pc){//显示进程表算法

while(pc[0].isNotFinish==true||pc[1].isNotFinish==true||pc[2].isNotFinish==true||pc[3].isNotFinish==true||pc[4].isNotFinish==true){

//*注意：||运算符，所有表达式都为false结果才为false,否则为true

for(int i=0i<pc.lengthi++){

pc[i].run(this)

}

System.out.println()

for(int i=0i<pc.lengthi++){//所有进程每执行完一次时间片长度的运行就重新按优先级排列一次

for(int j=ij<pc.lengthj++){

if(pc[i].privilege <pc[j].privilege){

temp = pc[i]

pc[i] = pc[j]

pc[j] = temp

}

}

}

}

}

}

class PCB {//声明进程类

int name,totaltime,runtime,privilege

boolean isNotFinish

public PCB(){

}

public PCB(int name, int totaltime, int privilege){

this.name = name//进程名

this.totaltime = totaltime//总时间

this.privilege = privilege//优先级别

this.runtime = 2//时间片，这里设值为2

this.isNotFinish = true//是否执行完毕

System.out.println("初始值： processname : " + name + " totaltime : " + totaltime + " privilege :" + privilege )

System.out.println()

}

public void run (MyQueue mq){//进程的基于时间片的执行算法

if(totaltime>1){

totaltime-=runtime//在总时间大于1的时候，总时间=总时间-时间片

privilege--

System.out.println(" processname : " + name + " remaintime : " + totaltime + " privilege :" + privilege )

}else if(totaltime==1){

totaltime--//在总时间为1时，执行时间为1

privilege--

System.out.println(" processname : " + name + " remaintime : " + totaltime + " privilege :" + privilege )

}else{

isNotFinish = false//总时间为0，将isNotFinish标记置为false

}

if(isNotFinish==true){

mq.deQueue()

mq.enQueue(this)

}

}

}

---