进程调度——简单轮转算法

#include<stdio.h>

#include<stdlib.h>

#include<malloc.h>

typedef struct process{//进程控制块

    int symbol;//进程标识符

    struct process *next;//指向下一个进程的指针，也是只赋了值

    int neednum;//进程所需要运行的时间

    int cpunum;//占用cpu的时间，初始值为0

    int timepiece;//时间片

    int state;//状态，1为ready，2为running，3为over，初始为1

}pro;
int judge(pro *p){//判断进程占用cpu的时间是否够了一个时间片，或是时间片的倍数

    int flag=0;

    if((p->cpunum%p->timepiece)==0){

        flag=1;

    }

    return flag;

}
void reorder(pro *p[],int n){//当某个进程够了一个时间片后，将它换到队尾

    pro *t;

    int i;

    t=p[0];

    for(i=0;i<n-1;i++){

        p[i]=p[i+1];

    }

    p[n-1]=t;

}
void createpro(pro *p){//进程初始化

    printf("symbol    ");

    scanf("%d",&p->symbol);

    printf("neednum    ");

    scanf("%d",&p->neednum);

    printf("cpunum    ");

    scanf("%d",&p->cpunum);

    printf("timepiece    ");

    scanf("%d",&p->timepiece);

    printf("state    ");

    scanf("%d",&p->state);

}
void resetpro(pro *p){//进程运行时执行的动作，所需时间减一，占用cpu时间加一

    p->neednum--;

    p->cpunum++;

}
void changestaterun(pro *p){//设置状态为running

    p->state=2;

}
void changestateready(pro *p){//设置状态为ready

    p->state=1;

}
int ifover(pro *p){//判断进程是否over

    int flag=0;

    if(p->neednum==0){

        flag=1;

    }

    return flag;

}
int proover(int n,pro *p[]){//如果某进程over

    int i;

    p[0]->state=3;//状态设置为over

    p[0]->cpunum=0;//这是由于在判断改进程是否over之后，还要执行一个if，判断cpunum是否是timepiece的倍数，而将cpunum设为0，则保证了不会满足上述条件

    for(i=0;i<n-1;i++){//删去该简称

        p[i]=p[i+1];

    }

    n--;//可运行进程数--

    return n;

}
int main(){
    pro *p1 = (pro *)malloc(sizeof(pro));//分配空间

    pro *p2 = (pro *)malloc(sizeof(pro));

    pro *p3 = (pro *)malloc(sizeof(pro));

    int coun=0,i;

    int f=0,ff=0;//保存ifover和judge的返回值

    pro *pp[10];//可执行进程序列，这次没有设置数组来保存over的进程，不过也可以设置

    createpro(p1);//初始化pro

    coun++;//可运行进程数++

    createpro(p2);

    coun++;

    createpro(p3);

    coun++;

    pp[0]=p1;//赋值

    pp[1]=p2;

    pp[2]=p3;

    char c;//调试，可以删掉

    int k;//用于for循环

    while(coun!=0&&(c=getchar())=='\n'){

        for(i=0;i<coun;i++){//打印出ready进程

            if(pp[i]->state==1){

                printf("process %d is ready!\n",pp[i]->symbol);

            }

            else if(pp[i]->state==3){

                printf("process %d is over!\n",pp[i]->symbol);

            }

        }

        for(k=0;k<coun-1;k++){//给pro中的next指针赋值

            pp[k]->next=pp[k+1];

        }

        printf("\n");

            changestaterun(pp[0]);//将进程状态改为running

            printf("process %d is running!\n",pp[0]->symbol);

            resetpro(pp[0]);//执行改变参数值

            printf("this turn is over!\n");

            changestateready(pp[0]);//将状态改回为ready

            printf("\n");

        f=ifover(pp[0]);//判断pro是否over

        if(f==1){

            coun=proover(coun,pp);//over则执行proover，并且将返回的当前可运行进程值赋值给coun

        }

        printf("%d\n",coun);

        ff=judge(pp[0]);//判断是否用完一个时间片

        if(ff==1)

        {

            reorder(pp,coun);//如果用完则将此元素放到队尾

        }

/*这次没有打印出那么对状态，主要是看顺序*/

    }

    return 0;

}

/*

1

3

0

2

1

2

4

0

3

1

3

2

0

4

1

*/

部分测试结果：