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

#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

*/

部分测试结果：