实验三 进程调度模拟程序

 

实验三 进程调度模拟程序

1.    目的和要求

1.1.           实验目的

用高级语言完成一个进程调度程序，以加深对进程的概念及进程调度算法的理解。

1.2.           实验要求

1.2.1例题：设计一个有 N个进程并发执行的进程调度模拟程序。

进程调度算法：采用最高优先级优先的调度算法（即把处理机分配给优先级最高的进程）和先来先服务（若优先级相同）算法。

(1).  每个进程有一个进程控制块（PCB）表示。进程控制块包含如下信息：进程名、优先级、到达时间、需要运行时间、已用CPU时间、进程状态等等。

(2).  进程的优先级及需要的运行时间可以事先人为地指定，进程的运行时间以时间片为单位进行计算。

(3).  每个进程的状态可以是就绪 r（ready）、运行R（Running）、或完成F（Finished）三种状态之一。

(4).  就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。

(5).  如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待调度。

(6).  每进行一次调度程序都打印一次运行进程、就绪队列中各个进程的 PCB，以便进行检查。 　　

(7).  重复以上过程，直到所要进程都完成为止。

思考：作业调度与进程调度的不同？

1.2.2实验题A：编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对N（N不小于5）个进程进行调度。

“最高优先级优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。

(1). 静态优先数是在创建进程时确定的，并在整个进程运行期间不再改变。

(2). 动态优先数是指进程的优先数在创建进程时可以给定一个初始值，并且可以按一定规则修改优先数。例如：在进程获得一次CPU后就将其优先数减少1，并且进程等待的时间超过某一时限（2个时间片时间）时增加其优先数等。

(3). （**）进程的优先数及需要的运行时间可以事先人为地指定，（也可以由随机数产生）。

(4). （**）在进行模拟调度过程可以创建（增加）进程，其到达时间为进程输入的时间。

0．

 

1.2.3实验题B：编写并调试一个模拟的进程调度程序，采用“基于时间片轮转法”调度算法对N（N不小于5）个进程进行调度。 “轮转法”有简单轮转法、多级反馈队列调度算法。

(1). 简单轮转法的基本思想是：所有就绪进程按 FCFS排成一个队列，总是把处理机分配给队首的进程，各进程占用CPU的时间片长度相同。如果运行进程用完它的时间片后还未完成，就把它送回到就绪队列的末尾，把处理机重新分配给队首的进程。直至所有的进程运行完毕。（此调度算法是否有优先级？）

 (2). 多级反馈队列调度算法的基本思想是：

将就绪队列分为N级（N＝3～5），每个就绪队列优先数不同并且分配给不同的时间片：队列级别越高，优先数越低，时间片越长；级别越小，优先数越高，时间片越短。

系统从第一级调度，当第一级为空时，系统转向第二级队列，.....当处于运行态的进程用完一个时间片，若未完成则放弃CPU，进入下一级队列。

当进程第一次就绪时，进入第一级队列。

(3). （**）考虑进程的阻塞状态B（Blocked）增加阻塞队列。进程的是否阻塞和阻塞的时间由产生的“随机数”确定（阻塞的频率和时间长度要较为合理）。注意进程只有处于运行状态才可能转换成阻塞状态，进程只有处于就绪状态才可以转换成运行状态。

 

2.    实验内容

根据指定的实验课题：A（1），A（2），B（1）和B（2）

完成设计、编码和调试工作，完成实验报告。

注：带**号的条目表示选做内容。

 

3.    实验环境

可以选用Turbo C作为开发环境。也可以选用Windows下的VB，CB等可视化环境，利用各种控件较为方便。自主选择实验环境。

4.    实验原理及核心算法参考程序段

     动态优先数（优先数只减不加）：

        

 

#include<sdio.h>
#include<string.h>
void shuru();
void readfiles();
void ran();
void sort(int choose);//1为到达时间排序，2为服务时间排序，3为HRRF排序，4为优先级排序
void FinishProcess();
typedef struct Process
{
    char name[10];
    char status;    //状态：开始s，等待d，就绪j
    int id;
    int arrtime;    //到达时间
    int reqtime;    //要求服务时间
    int startime;    //开始时间
    int finitime;    //完成时间
    int dotime;        //已经工作时间

    float TAtime,TAWtime;    //周转时间、带权周转时间
    float prio;        //优先级
    float HRRF;            //响应比

}Process;


Process Processes[100]; //最多100个作业
int systime=0,bfsum,add,del;
int intarr,infin,intjob,sumProcess;
char T='A';              //T的默认值是A

void RunProcess()
{
    int i=1;
    sort(4);//按prio排序
    printf("\n————开始运行————\n");
    for(i=1;i<=sumProcess;i++)
    {
        printf("\n\tProcess %s\t%f\n",Processes[i].name,Processes[i].prio);
    }
    Processes[1].dotime++;
    if(Processes[1].dotime==Processes[1].reqtime)
    {
        FinishProcess();
    }
    Processes[1].prio--;
}

void FinishProcess()
{
    int i,j;
    Process temp;
    for(i=1;i<=sumProcess;i++)
    {
        j=i-1;
                    strcpy(temp.name,Processes[i].name);
                    temp.status=Processes[i].status;
                    temp.arrtime=Processes[i].arrtime;
                    temp.reqtime=Processes[i].reqtime;
                    temp.startime=Processes[i].startime;
                    temp.finitime=Processes[i].finitime;
                    temp.TAtime=Processes[i].TAtime;
                    temp.TAWtime=Processes[i].TAWtime;
                    temp.prio=Processes[i].prio;
                    temp.id=Processes[i].id;
                    temp.HRRF=Processes[i].HRRF;
                    temp.dotime=Processes[i].dotime;

                    strcpy(Processes[i].name,Processes[j].name);
                    Processes[i].status=Processes[j].status;
                    Processes[i].arrtime=Processes[j].arrtime;
                    Processes[i].reqtime=Processes[j].reqtime;
                    Processes[i].startime=Processes[j].startime;
                    Processes[i].finitime=Processes[j].finitime;
                    Processes[i].TAtime=Processes[j].TAtime;
                    Processes[i].TAWtime=Processes[j].TAWtime;
                    Processes[i].prio=Processes[j].prio;
                    Processes[i].id=Processes[j].id;
                    Processes[i].HRRF=Processes[j].HRRF;
                    Processes[i].dotime=Processes[j].dotime;

                    strcpy(Processes[j].name,temp.name);
                    Processes[j].status=temp.status;
                    Processes[j].arrtime=temp.arrtime;
                    Processes[j].reqtime=temp.reqtime;
                    Processes[j].startime=temp.startime;
                    Processes[j].finitime=temp.finitime;
                    Processes[j].TAtime=temp.TAtime;
                    Processes[j].TAWtime=temp.TAWtime;
                    Processes[j].prio=temp.prio;
                    Processes[j].id=temp.id;
                    Processes[j].HRRF=temp.HRRF;
                    Processes[j].dotime=temp.dotime;
    }
    sumProcess--;
}



void sort(int choose)  //排序
{
    int i,j;
    Process temp;
    for(i=1;i<=sumProcess;i++)
    {
        for(j=i+1;j<=sumProcess;j++)
        {
            if(choose==1)
            {
                if(Processes[i].arrtime>Processes[j].arrtime)
                {
                    strcpy(temp.name,Processes[i].name);
                    temp.status=Processes[i].status;
                    temp.arrtime=Processes[i].arrtime;
                    temp.reqtime=Processes[i].reqtime;
                    temp.startime=Processes[i].startime;
                    temp.finitime=Processes[i].finitime;
                    temp.TAtime=Processes[i].TAtime;
                    temp.TAWtime=Processes[i].TAWtime;
                    temp.prio=Processes[i].prio;
                    temp.id=Processes[i].id;
                    temp.HRRF=Processes[i].HRRF;
                    temp.dotime=Processes[i].dotime;

                    strcpy(Processes[i].name,Processes[j].name);
                    Processes[i].status=Processes[j].status;
                    Processes[i].arrtime=Processes[j].arrtime;
                    Processes[i].reqtime=Processes[j].reqtime;
                    Processes[i].startime=Processes[j].startime;
                    Processes[i].finitime=Processes[j].finitime;
                    Processes[i].TAtime=Processes[j].TAtime;
                    Processes[i].TAWtime=Processes[j].TAWtime;
                    Processes[i].prio=Processes[j].prio;
                    Processes[i].id=Processes[j].id;
                    Processes[i].HRRF=Processes[j].HRRF;
                    Processes[i].dotime=Processes[j].dotime;

                    strcpy(Processes[j].name,temp.name);
                    Processes[j].status=temp.status;
                    Processes[j].arrtime=temp.arrtime;
                    Processes[j].reqtime=temp.reqtime;
                    Processes[j].startime=temp.startime;
                    Processes[j].finitime=temp.finitime;
                    Processes[j].TAtime=temp.TAtime;
                    Processes[j].TAWtime=temp.TAWtime;
                    Processes[j].prio=temp.prio;
                    Processes[j].id=temp.id;
                    Processes[j].HRRF=temp.HRRF;
                    Processes[j].dotime=temp.dotime;
                }
            }
            else if(choose==2)
            {
                if(Processes[i].reqtime>Processes[j].reqtime)
                {
                    strcpy(temp.name,Processes[i].name);
                    temp.status=Processes[i].status;
                    temp.arrtime=Processes[i].arrtime;
                    temp.reqtime=Processes[i].reqtime;
                    temp.startime=Processes[i].startime;
                    temp.finitime=Processes[i].finitime;
                    temp.TAtime=Processes[i].TAtime;
                    temp.TAWtime=Processes[i].TAWtime;
                    temp.prio=Processes[i].prio;
                    temp.id=Processes[i].id;
                    temp.HRRF=Processes[i].HRRF;
                    temp.dotime=Processes[i].dotime;

                    strcpy(Processes[i].name,Processes[j].name);
                    Processes[i].status=Processes[j].status;
                    Processes[i].arrtime=Processes[j].arrtime;
                    Processes[i].reqtime=Processes[j].reqtime;
                    Processes[i].startime=Processes[j].startime;
                    Processes[i].finitime=Processes[j].finitime;
                    Processes[i].TAtime=Processes[j].TAtime;
                    Processes[i].TAWtime=Processes[j].TAWtime;
                    Processes[i].prio=Processes[j].prio;
                    Processes[i].id=Processes[j].id;
                    Processes[i].HRRF=Processes[j].HRRF;
                    Processes[i].dotime=Processes[j].dotime;

                    strcpy(Processes[j].name,temp.name);
                    Processes[j].status=temp.status;
                    Processes[j].arrtime=temp.arrtime;
                    Processes[j].reqtime=temp.reqtime;
                    Processes[j].startime=temp.startime;
                    Processes[j].finitime=temp.finitime;
                    Processes[j].TAtime=temp.TAtime;
                    Processes[j].TAWtime=temp.TAWtime;
                    Processes[j].prio=temp.prio;
                    Processes[j].id=temp.id;
                    Processes[j].HRRF=temp.HRRF;
                    Processes[j].dotime=temp.dotime;
                }
            }
            else if(choose==3)
            {
                if(Processes[i].HRRF<Processes[j].HRRF)
                {
                    strcpy(temp.name,Processes[i].name);
                    temp.status=Processes[i].status;
                    temp.arrtime=Processes[i].arrtime;
                    temp.reqtime=Processes[i].reqtime;
                    temp.startime=Processes[i].startime;
                    temp.finitime=Processes[i].finitime;
                    temp.TAtime=Processes[i].TAtime;
                    temp.TAWtime=Processes[i].TAWtime;
                    temp.prio=Processes[i].prio;
                    temp.id=Processes[i].id;
                    temp.HRRF=Processes[i].HRRF;
                    temp.dotime=Processes[i].dotime;

                    strcpy(Processes[i].name,Processes[j].name);
                    Processes[i].status=Processes[j].status;
                    Processes[i].arrtime=Processes[j].arrtime;
                    Processes[i].reqtime=Processes[j].reqtime;
                    Processes[i].startime=Processes[j].startime;
                    Processes[i].finitime=Processes[j].finitime;
                    Processes[i].TAtime=Processes[j].TAtime;
                    Processes[i].TAWtime=Processes[j].TAWtime;
                    Processes[i].prio=Processes[j].prio;
                    Processes[i].id=Processes[j].id;
                    Processes[i].HRRF=Processes[j].HRRF;
                    Processes[i].dotime=Processes[j].dotime;

                    strcpy(Processes[j].name,temp.name);
                    Processes[j].status=temp.status;
                    Processes[j].arrtime=temp.arrtime;
                    Processes[j].reqtime=temp.reqtime;
                    Processes[j].startime=temp.startime;
                    Processes[j].finitime=temp.finitime;
                    Processes[j].TAtime=temp.TAtime;
                    Processes[j].TAWtime=temp.TAWtime;
                    Processes[j].prio=temp.prio;
                    Processes[j].id=temp.id;
                    Processes[j].HRRF=temp.HRRF;
                    Processes[j].dotime=temp.dotime;
                }
            }
            else if(choose==4)
            {
                if(Processes[i].prio<Processes[j].prio)
                {
                    strcpy(temp.name,Processes[i].name);
                    temp.status=Processes[i].status;
                    temp.arrtime=Processes[i].arrtime;
                    temp.reqtime=Processes[i].reqtime;
                    temp.startime=Processes[i].startime;
                    temp.finitime=Processes[i].finitime;
                    temp.TAtime=Processes[i].TAtime;
                    temp.TAWtime=Processes[i].TAWtime;
                    temp.prio=Processes[i].prio;
                    temp.id=Processes[i].id;
                    temp.HRRF=Processes[i].HRRF;
                    temp.dotime=Processes[i].dotime;

                    strcpy(Processes[i].name,Processes[j].name);
                    Processes[i].status=Processes[j].status;
                    Processes[i].arrtime=Processes[j].arrtime;
                    Processes[i].reqtime=Processes[j].reqtime;
                    Processes[i].startime=Processes[j].startime;
                    Processes[i].finitime=Processes[j].finitime;
                    Processes[i].TAtime=Processes[j].TAtime;
                    Processes[i].TAWtime=Processes[j].TAWtime;
                    Processes[i].prio=Processes[j].prio;
                    Processes[i].id=Processes[j].id;
                    Processes[i].HRRF=Processes[j].HRRF;
                    Processes[i].dotime=Processes[j].dotime;

                    strcpy(Processes[j].name,temp.name);
                    Processes[j].status=temp.status;
                    Processes[j].arrtime=temp.arrtime;
                    Processes[j].reqtime=temp.reqtime;
                    Processes[j].startime=temp.startime;
                    Processes[j].finitime=temp.finitime;
                    Processes[j].TAtime=temp.TAtime;
                    Processes[j].TAWtime=temp.TAWtime;
                    Processes[j].prio=temp.prio;
                    Processes[j].id=temp.id;
                    Processes[j].HRRF=temp.HRRF;
                    Processes[j].dotime=temp.dotime;
                }
            }
            else 
                printf("Error!\n");
        }
    }
}
void ins()    //插入
{
    int i;
    while(T!='E'&&T!='e')
    {
            printf("'I'nsert or 'D'elete or 'E'xit?\n");
            getchar();
            scanf("%c",&T);
            if(T=='I'||T=='i')
            {
                printf("你想插入多少个作业?\n");
                scanf("%d",&add);
                bfsum=sumProcess;
                sumProcess=sumProcess+add;
                for(i=bfsum+1;i<=sumProcess;i++)
                {
                    printf("\n第%d个作业:\n",i);
                    getchar();
                    printf("输入作业名:\n");
                    gets(Processes[i].name);
                    printf("到达时间:\n");
                    scanf("%d",&Processes[i].arrtime);
                    printf("要求服务时间:\n");
                    scanf("%d",&Processes[i].reqtime);
                }
            }
            else if(T=='D'||T=='d')
            {
                printf("你想删除第几组?");
                scanf("%d",&del);
                for(i=del;i<=sumProcess-1;i++)
                {
                    strcpy(Processes[i].name,Processes[i+1].name);
                    Processes[i].arrtime=Processes[i+1].arrtime;
                    Processes[i].reqtime=Processes[i+1].reqtime;
                }
                sumProcess--;
            }
    }
}


void printarr()    //打印
{
    int i;
    printf("\t\tname\tartime\trqtime\n");
    for(i=1;i<=sumProcess;i++)
    {
        printf("N  %d\t",i);
        printf("\t%s",Processes[i].name);
        printf("\t%d",Processes[i].arrtime);
        printf("\t%d\n",Processes[i].reqtime);
    }
    printf("\t\t\t\t\t\t现在系统时间%d\n",systime);
    
}
void printz()
{
    int i;
    float sum1=0,sum2=0;    //计算平均周转时间、平均带权周转时间
    printf("\t\tname\tartime\trqtime\tstime\tftime\tTAtime\t\tTAWtime\n");
    for(i=1;i<=sumProcess;i++)
    {
        printf("N  %d\t",i);
        printf("\t%s",Processes[i].name);
        printf("\t%d",Processes[i].arrtime);
        printf("\t%d",Processes[i].reqtime);
        printf("\t%d",Processes[i].startime);
        printf("\t%d",Processes[i].finitime);
        printf("\t%f",Processes[i].TAtime);
        printf("\t%f\n",Processes[i].TAWtime);
    }
    for(i=1;i<=sumProcess;i++)
    {
        sum1=sum1+Processes[i].TAtime;
    }
    for(i=1;i<=sumProcess;i++)
    {
        sum2=sum2+Processes[i].TAWtime;
    }
    printf("\n平均周转时间=%f\n",sum1/sumProcess);
    printf("\n平均带权周转时间=%f\n",sum2/sumProcess);
    printf("\t\t\t\t\t\t现在系统时间%d\n",systime);
}
void sumofthey()
{
    int i;
    Processes[1].startime=Processes[1].arrtime;
    Processes[1].finitime=Processes[1].arrtime+Processes[1].reqtime;
    Processes[1].TAtime=(float)(Processes[1].finitime-Processes[1].arrtime);
    Processes[1].TAWtime=(float)(Processes[1].TAtime/Processes[1].reqtime);
    Processes[1].HRRF=(float)(Processes[1].TAtime/Processes[1].reqtime);
    for(i=2;i<=sumProcess;i++)
    {
        Processes[i].startime=Processes[i-1].finitime;
        Processes[i].finitime=Processes[i].startime+Processes[i].reqtime;
        Processes[i].TAtime=(float)(Processes[i].finitime-Processes[i].arrtime);
        Processes[i].TAWtime=(float)(Processes[i].TAtime/Processes[i].reqtime);
        Processes[i].HRRF=(float)(Processes[i].TAtime/Processes[i].reqtime);
    }
}
void startit()
{
    int n;
    printf("\n");
    printf("\t\t\t**************************\n");
    printf("\t\t\t**1.调用文本写入数据******\n");
    printf("\t\t\t**2.调用伪随机数产生数据**\n");
    printf("\t\t\t**3.调用自己输入模拟数据**\n");
    printf("\t\t\t**************************\n");
    scanf("%d",&n);
    switch(n)
    {
    case 1:
        readfiles();
        sumofthey();
        break;
    case 2:
        ran();
        sumofthey();
        break;
    case 3:
        shuru();
        sumofthey();
        break;
    default:
        {
        printf("输入有误，请重新输入");
        break;
        }
    }
}
void ran()
{
    int i;
    srand((unsigned)time(0));  //参数seed是rand()的种子，用来初始化rand()的起始值。
    sumProcess=rand()%3+5;
    for(i=1;i<=sumProcess;i++)
    {
        itoa(i,Processes[i].name,2);
     
        Processes[i].arrtime=rand()%29+1;
    
        Processes[i].reqtime=rand()%7+1;

        Processes[i].prio=rand()%10+1;
    }
    printf("\n \tid    \t作业到达时间     \t作业运行所需要时间     \t优先级\n");
    for(i=1; i<=sumProcess; i++)
    {
        printf("\n\t%s\t%12d\t%15d\t%25f",Processes[i].name,Processes[i].arrtime,Processes[i].reqtime,Processes[i].prio);
    }
   printf("\n");
}

void readfiles()
{
    char szTest[1000] = {0};int i=0,n;
    FILE *fp=fopen("D:\\File1.txt","r");
    //FILE *fout=fopen("D:\\File2.txt","w");
    if(fp == NULL)
    {
        printf("ERROR!\n");
        exit(0);
    }
    //fscanf(fp,"Processesum=%d\n",%n);
    while(!feof(fp))  
    {
        fscanf(fp,"%d%d%d",&Processes[i].id,&Processes[i].arrtime,&Processes[i].reqtime);  //fscanf()函数将数据读入
        printf("\n%3d%12d%15d\n",Processes[i].id,Processes[i].arrtime,Processes[i].reqtime);  //输出到屏幕
        itoa(Processes[i].id,Processes[i].name,10);
        i++;
        /*memset(szTest, 0, sizeof(szTest));
        fscanf(fp,"@id=%d|",&i);
        fgets(fp,"name=%s|",Processes[i].name);
        fscanf(fp,"arrtime=%d|reqtime=%d\n",&Processes[i].arrtime,&Processes[i].reqtime);
        */
    //fscanf(fp,"%d",)
    }
    sumProcess=i;
    fclose(fp);
}
void shuru()
{
    int i;
    printf("作业个数:\n");
    scanf("%d",&sumProcess);
    for(i=1;i<=sumProcess;i++)
    {
        printf("\n第%d个作业:\n",i);
        getchar();
        printf("输入作业名:\n");
        gets(Processes[i].name);
        printf("到达时间:\n");
        scanf("%d",&Processes[i].arrtime);
        printf("要求服务时间:\n");
        scanf("%d",&Processes[i].reqtime);
    }
    sumofthey();
}
void choosesort()
{
    int n;
    printf("\t\t\t*****************************\n");
    printf("\t\t\t*******1.FCFS算法调度********\n");
    printf("\t\t\t*******2.SJF算法调度*********\n");
    printf("\t\t\t*******3.HRRF算法调度********\n");
    printf("\t\t\t*******4.调用系统清屏********\n");
    printf("\t\t\t*******5.退出算法调度********\n");
    printf("\t\t\t*****************************\n");
    scanf("%d",&n);
    switch(n)
    {
    case 1:
        printf("运行先来先服务算法FCFS\n");
        sort(1);
        printf("\n经按到达时间排序后，未达到队列是\n");
        printz();
        break;
    case 2:
        printf("运行最短作业优先算法FJS\n");
        sort(2);
        printf("\n经按到达时间排序后，未达到队列是\n");
        printz();
        break;
    case 3:
        printf("运行最高响应比优先算法HRRF\n");
        sort(3);
        printf("\n经按到达时间排序后，未达到队列是\n");
        printz();
        break;
    case 4:
        system("cls");
        break;
    case 5:
        exit(0);
        break;
    }
}
void main()
{
    startit();
//    choosesort();
    while(sumProcess!=0)
    {
        RunProcess();
    }

}

 

#include<stdio.h>
#include<string.h>
void shuru();
void readfiles();
void ran();
void sort(int choose);//1为到达时间排序，2为服务时间排序，3为HRRF排序，4为优先级排序
void FinishProcess();
typedef struct Process
{
    char name[10];
    char status;    //状态：开始s，等待d，就绪j
    int id;
    int arrtime;    //到达时间
    int reqtime;    //要求服务时间
    int startime;    //开始时间
    int finitime;    //完成时间
    int dotime;        //已经工作时间

    float TAtime,TAWtime;    //周转时间、带权周转时间
    float prio;        //优先级
    float HRRF;            //响应比

}Process;


Process Processes[100]; //最多100个作业
int systime=0,bfsum,add,del;
int intarr,infin,intjob,sumProcess;
char T='A';              //T的默认值是A

void RunProcess()
{
    int timeflag=0;
    int timepiece=2;
    int T;
    int k;
    char ch;
    int i=1;

    printf("\n请输入时间片：");
    scanf("%d",&T);

    sort(1);//按FCFS排序
    printf("\n————开始运行————\n");
    while(sumProcess>=0)
    {
        if(timeflag==T)
        {
            timeflag=0;
            if(Processes[0].reqtime==0)
            {
            printf("————进程%s已完成————\n",Processes[0].name);
            

            if(sumProcess!=0){
                sort(1);
                printf("当前正在运行进程是:%s————\n",Processes[0].name);
            }
            if(sumProcess>=1)
                for(k=1;k<sumProcess;k++)
                printf("————进程%s正在等待————\n",Processes[k].name);
            if(sumProcess==0){
                Processes[0].reqtime--;
                sumProcess--;
            }
            }
            else{
                sort(1);
                if(sumProcess!=0){
                //sort();
                printf("当前正在运行进程是:%s————\n",Processes[0].name);
                }
                if(sumProcess>=1)
                for(k=1;k<sumProcess;k++)
                printf("————进程%s正在等待————\n",Processes[k].name);
            }              
        }
        else{
            if(Processes[0].reqtime==0)
            {
            printf("————进程%s已完成————\n",Processes[0].name);
            if(sumProcess!=0){
                sort(1);
                printf("————进程%s正在运行————\n",Processes[0].name);
            }
            if(sumProcess>=1)
                for(k=1;k<sumProcess;k++)
                printf("————进程%s正在等待————\n",Processes[k].name);
            }
            else{
                Processes[0].reqtime--;
                if(sumProcess!=0)
                printf("————进程%s正在运行————\n",Processes[0].name);
            
                if(sumProcess>=1)
                for(k=1;k<sumProcess;k++)
                printf("————进程%s正在等待————\n",Processes[k].name);
            }
        }
        timeflag++;
        printf("\n 按任回车继续......"); 
        ch=getchar(); 
        ch=getchar();
    }
     printf("\n\n 全部进程已经完成.\n"); 
/*
    for(i=1;i<=sumProcess;i++)
    {
        printf("\n\tProcess %s\t%f\n",Processes[i].name,Processes[i].prio);
    }
    Processes[1].dotime++;
    if(Processes[1].dotime==Processes[1].reqtime)
    {
        FinishProcess();
    }
    Processes[1].prio--;*/
}

void FinishProcess()
{
    int i,j;
    Process temp;
    for(i=1;i<=sumProcess;i++)
    {
        j=i-1;
                    strcpy(temp.name,Processes[i].name);
                    temp.status=Processes[i].status;
                    temp.arrtime=Processes[i].arrtime;
                    temp.reqtime=Processes[i].reqtime;
                    temp.startime=Processes[i].startime;
                    temp.finitime=Processes[i].finitime;
                    temp.TAtime=Processes[i].TAtime;
                    temp.TAWtime=Processes[i].TAWtime;
                    temp.prio=Processes[i].prio;
                    temp.id=Processes[i].id;
                    temp.HRRF=Processes[i].HRRF;
                    temp.dotime=Processes[i].dotime;

                    strcpy(Processes[i].name,Processes[j].name);
                    Processes[i].status=Processes[j].status;
                    Processes[i].arrtime=Processes[j].arrtime;
                    Processes[i].reqtime=Processes[j].reqtime;
                    Processes[i].startime=Processes[j].startime;
                    Processes[i].finitime=Processes[j].finitime;
                    Processes[i].TAtime=Processes[j].TAtime;
                    Processes[i].TAWtime=Processes[j].TAWtime;
                    Processes[i].prio=Processes[j].prio;
                    Processes[i].id=Processes[j].id;
                    Processes[i].HRRF=Processes[j].HRRF;
                    Processes[i].dotime=Processes[j].dotime;

                    strcpy(Processes[j].name,temp.name);
                    Processes[j].status=temp.status;
                    Processes[j].arrtime=temp.arrtime;
                    Processes[j].reqtime=temp.reqtime;
                    Processes[j].startime=temp.startime;
                    Processes[j].finitime=temp.finitime;
                    Processes[j].TAtime=temp.TAtime;
                    Processes[j].TAWtime=temp.TAWtime;
                    Processes[j].prio=temp.prio;
                    Processes[j].id=temp.id;
                    Processes[j].HRRF=temp.HRRF;
                    Processes[j].dotime=temp.dotime;
    }
    sumProcess--;
}



void sort(int choose)  //排序
{
    int i,j;
    Process temp;
    for(i=1;i<=sumProcess;i++)
    {
        for(j=i+1;j<=sumProcess;j++)
        {
            if(choose==1)
            {
                if(Processes[i].arrtime>Processes[j].arrtime)
                {
                    strcpy(temp.name,Processes[i].name);
                    temp.status=Processes[i].status;
                    temp.arrtime=Processes[i].arrtime;
                    temp.reqtime=Processes[i].reqtime;
                    temp.startime=Processes[i].startime;
                    temp.finitime=Processes[i].finitime;
                    temp.TAtime=Processes[i].TAtime;
                    temp.TAWtime=Processes[i].TAWtime;
                    temp.prio=Processes[i].prio;
                    temp.id=Processes[i].id;
                    temp.HRRF=Processes[i].HRRF;
                    temp.dotime=Processes[i].dotime;

                    strcpy(Processes[i].name,Processes[j].name);
                    Processes[i].status=Processes[j].status;
                    Processes[i].arrtime=Processes[j].arrtime;
                    Processes[i].reqtime=Processes[j].reqtime;
                    Processes[i].startime=Processes[j].startime;
                    Processes[i].finitime=Processes[j].finitime;
                    Processes[i].TAtime=Processes[j].TAtime;
                    Processes[i].TAWtime=Processes[j].TAWtime;
                    Processes[i].prio=Processes[j].prio;
                    Processes[i].id=Processes[j].id;
                    Processes[i].HRRF=Processes[j].HRRF;
                    Processes[i].dotime=Processes[j].dotime;

                    strcpy(Processes[j].name,temp.name);
                    Processes[j].status=temp.status;
                    Processes[j].arrtime=temp.arrtime;
                    Processes[j].reqtime=temp.reqtime;
                    Processes[j].startime=temp.startime;
                    Processes[j].finitime=temp.finitime;
                    Processes[j].TAtime=temp.TAtime;
                    Processes[j].TAWtime=temp.TAWtime;
                    Processes[j].prio=temp.prio;
                    Processes[j].id=temp.id;
                    Processes[j].HRRF=temp.HRRF;
                    Processes[j].dotime=temp.dotime;
                }
            }
            else if(choose==2)
            {
                if(Processes[i].reqtime>Processes[j].reqtime)
                {
                    strcpy(temp.name,Processes[i].name);
                    temp.status=Processes[i].status;
                    temp.arrtime=Processes[i].arrtime;
                    temp.reqtime=Processes[i].reqtime;
                    temp.startime=Processes[i].startime;
                    temp.finitime=Processes[i].finitime;
                    temp.TAtime=Processes[i].TAtime;
                    temp.TAWtime=Processes[i].TAWtime;
                    temp.prio=Processes[i].prio;
                    temp.id=Processes[i].id;
                    temp.HRRF=Processes[i].HRRF;
                    temp.dotime=Processes[i].dotime;

                    strcpy(Processes[i].name,Processes[j].name);
                    Processes[i].status=Processes[j].status;
                    Processes[i].arrtime=Processes[j].arrtime;
                    Processes[i].reqtime=Processes[j].reqtime;
                    Processes[i].startime=Processes[j].startime;
                    Processes[i].finitime=Processes[j].finitime;
                    Processes[i].TAtime=Processes[j].TAtime;
                    Processes[i].TAWtime=Processes[j].TAWtime;
                    Processes[i].prio=Processes[j].prio;
                    Processes[i].id=Processes[j].id;
                    Processes[i].HRRF=Processes[j].HRRF;
                    Processes[i].dotime=Processes[j].dotime;

                    strcpy(Processes[j].name,temp.name);
                    Processes[j].status=temp.status;
                    Processes[j].arrtime=temp.arrtime;
                    Processes[j].reqtime=temp.reqtime;
                    Processes[j].startime=temp.startime;
                    Processes[j].finitime=temp.finitime;
                    Processes[j].TAtime=temp.TAtime;
                    Processes[j].TAWtime=temp.TAWtime;
                    Processes[j].prio=temp.prio;
                    Processes[j].id=temp.id;
                    Processes[j].HRRF=temp.HRRF;
                    Processes[j].dotime=temp.dotime;
                }
            }
            else if(choose==3)
            {
                if(Processes[i].HRRF<Processes[j].HRRF)
                {
                    strcpy(temp.name,Processes[i].name);
                    temp.status=Processes[i].status;
                    temp.arrtime=Processes[i].arrtime;
                    temp.reqtime=Processes[i].reqtime;
                    temp.startime=Processes[i].startime;
                    temp.finitime=Processes[i].finitime;
                    temp.TAtime=Processes[i].TAtime;
                    temp.TAWtime=Processes[i].TAWtime;
                    temp.prio=Processes[i].prio;
                    temp.id=Processes[i].id;
                    temp.HRRF=Processes[i].HRRF;
                    temp.dotime=Processes[i].dotime;

                    strcpy(Processes[i].name,Processes[j].name);
                    Processes[i].status=Processes[j].status;
                    Processes[i].arrtime=Processes[j].arrtime;
                    Processes[i].reqtime=Processes[j].reqtime;
                    Processes[i].startime=Processes[j].startime;
                    Processes[i].finitime=Processes[j].finitime;
                    Processes[i].TAtime=Processes[j].TAtime;
                    Processes[i].TAWtime=Processes[j].TAWtime;
                    Processes[i].prio=Processes[j].prio;
                    Processes[i].id=Processes[j].id;
                    Processes[i].HRRF=Processes[j].HRRF;
                    Processes[i].dotime=Processes[j].dotime;

                    strcpy(Processes[j].name,temp.name);
                    Processes[j].status=temp.status;
                    Processes[j].arrtime=temp.arrtime;
                    Processes[j].reqtime=temp.reqtime;
                    Processes[j].startime=temp.startime;
                    Processes[j].finitime=temp.finitime;
                    Processes[j].TAtime=temp.TAtime;
                    Processes[j].TAWtime=temp.TAWtime;
                    Processes[j].prio=temp.prio;
                    Processes[j].id=temp.id;
                    Processes[j].HRRF=temp.HRRF;
                    Processes[j].dotime=temp.dotime;
                }
            }
            else if(choose==4)
            {
                if(Processes[i].prio<Processes[j].prio)
                {
                    strcpy(temp.name,Processes[i].name);
                    temp.status=Processes[i].status;
                    temp.arrtime=Processes[i].arrtime;
                    temp.reqtime=Processes[i].reqtime;
                    temp.startime=Processes[i].startime;
                    temp.finitime=Processes[i].finitime;
                    temp.TAtime=Processes[i].TAtime;
                    temp.TAWtime=Processes[i].TAWtime;
                    temp.prio=Processes[i].prio;
                    temp.id=Processes[i].id;
                    temp.HRRF=Processes[i].HRRF;
                    temp.dotime=Processes[i].dotime;

                    strcpy(Processes[i].name,Processes[j].name);
                    Processes[i].status=Processes[j].status;
                    Processes[i].arrtime=Processes[j].arrtime;
                    Processes[i].reqtime=Processes[j].reqtime;
                    Processes[i].startime=Processes[j].startime;
                    Processes[i].finitime=Processes[j].finitime;
                    Processes[i].TAtime=Processes[j].TAtime;
                    Processes[i].TAWtime=Processes[j].TAWtime;
                    Processes[i].prio=Processes[j].prio;
                    Processes[i].id=Processes[j].id;
                    Processes[i].HRRF=Processes[j].HRRF;
                    Processes[i].dotime=Processes[j].dotime;

                    strcpy(Processes[j].name,temp.name);
                    Processes[j].status=temp.status;
                    Processes[j].arrtime=temp.arrtime;
                    Processes[j].reqtime=temp.reqtime;
                    Processes[j].startime=temp.startime;
                    Processes[j].finitime=temp.finitime;
                    Processes[j].TAtime=temp.TAtime;
                    Processes[j].TAWtime=temp.TAWtime;
                    Processes[j].prio=temp.prio;
                    Processes[j].id=temp.id;
                    Processes[j].HRRF=temp.HRRF;
                    Processes[j].dotime=temp.dotime;
                }
            }
            else 
                printf("Error!\n");
        }
    }
}
void ins()    //插入
{
    int i;
    while(T!='E'&&T!='e')
    {
            printf("'I'nsert or 'D'elete or 'E'xit?\n");
            getchar();
            scanf("%c",&T);
            if(T=='I'||T=='i')
            {
                printf("你想插入多少个作业?\n");
                scanf("%d",&add);
                bfsum=sumProcess;
                sumProcess=sumProcess+add;
                for(i=bfsum+1;i<=sumProcess;i++)
                {
                    printf("\n第%d个作业:\n",i);
                    getchar();
                    printf("输入作业名:\n");
                    gets(Processes[i].name);
                    printf("到达时间:\n");
                    scanf("%d",&Processes[i].arrtime);
                    printf("要求服务时间:\n");
                    scanf("%d",&Processes[i].reqtime);
                }
            }
            else if(T=='D'||T=='d')
            {
                printf("你想删除第几组?");
                scanf("%d",&del);
                for(i=del;i<=sumProcess-1;i++)
                {
                    strcpy(Processes[i].name,Processes[i+1].name);
                    Processes[i].arrtime=Processes[i+1].arrtime;
                    Processes[i].reqtime=Processes[i+1].reqtime;
                }
                sumProcess--;
            }
    }
}


void printarr()    //打印
{
    int i;
    printf("\t\tname\tartime\trqtime\n");
    for(i=1;i<=sumProcess;i++)
    {
        printf("N  %d\t",i);
        printf("\t%s",Processes[i].name);
        printf("\t%d",Processes[i].arrtime);
        printf("\t%d\n",Processes[i].reqtime);
    }
    printf("\t\t\t\t\t\t现在系统时间%d\n",systime);
    
}
void printz()
{
    int i;
    float sum1=0,sum2=0;    //计算平均周转时间、平均带权周转时间
    printf("\t\tname\tartime\trqtime\tstime\tftime\tTAtime\t\tTAWtime\n");
    for(i=1;i<=sumProcess;i++)
    {
        printf("N  %d\t",i);
        printf("\t%s",Processes[i].name);
        printf("\t%d",Processes[i].arrtime);
        printf("\t%d",Processes[i].reqtime);
        printf("\t%d",Processes[i].startime);
        printf("\t%d",Processes[i].finitime);
        printf("\t%f",Processes[i].TAtime);
        printf("\t%f\n",Processes[i].TAWtime);
    }
    for(i=1;i<=sumProcess;i++)
    {
        sum1=sum1+Processes[i].TAtime;
    }
    for(i=1;i<=sumProcess;i++)
    {
        sum2=sum2+Processes[i].TAWtime;
    }
    printf("\n平均周转时间=%f\n",sum1/sumProcess);
    printf("\n平均带权周转时间=%f\n",sum2/sumProcess);
    printf("\t\t\t\t\t\t现在系统时间%d\n",systime);
}
void sumofthey()
{
    int i;
    Processes[1].startime=Processes[1].arrtime;
    Processes[1].finitime=Processes[1].arrtime+Processes[1].reqtime;
    Processes[1].TAtime=(float)(Processes[1].finitime-Processes[1].arrtime);
    Processes[1].TAWtime=(float)(Processes[1].TAtime/Processes[1].reqtime);
    Processes[1].HRRF=(float)(Processes[1].TAtime/Processes[1].reqtime);
    for(i=2;i<=sumProcess;i++)
    {
        Processes[i].startime=Processes[i-1].finitime;
        Processes[i].finitime=Processes[i].startime+Processes[i].reqtime;
        Processes[i].TAtime=(float)(Processes[i].finitime-Processes[i].arrtime);
        Processes[i].TAWtime=(float)(Processes[i].TAtime/Processes[i].reqtime);
        Processes[i].HRRF=(float)(Processes[i].TAtime/Processes[i].reqtime);
    }
}
void startit()
{
    int n;
    printf("\n");
    printf("\t\t\t**************************\n");
    printf("\t\t\t**1.调用文本写入数据******\n");
    printf("\t\t\t**2.调用伪随机数产生数据**\n");
    printf("\t\t\t**3.调用自己输入模拟数据**\n");
    printf("\t\t\t**************************\n");
    scanf("%d",&n);
    switch(n)
    {
    case 1:
        readfiles();
        sumofthey();
        break;
    case 2:
        ran();
        sumofthey();
        break;
    case 3:
        shuru();
        sumofthey();
        break;
    default:
        {
        printf("输入有误，请重新输入");
        break;
        }
    }
}
void ran()
{
    int i;
    srand((unsigned)time(0));  //参数seed是rand()的种子，用来初始化rand()的起始值。
    sumProcess=rand()%3+5;
    for(i=1;i<=sumProcess;i++)
    {
        itoa(i,Processes[i].name,2);
     
        Processes[i].arrtime=rand()%29+1;
    
        Processes[i].reqtime=rand()%7+1;

        Processes[i].prio=rand()%10+1;
    }
    printf("\n \tid    \t作业到达时间     \t作业运行所需要时间     \t优先级\n");
    for(i=1; i<=sumProcess; i++)
    {
        printf("\n\t%s\t%12d\t%15d\t%25f",Processes[i].name,Processes[i].arrtime,Processes[i].reqtime,Processes[i].prio);
    }
   printf("\n");
}

void readfiles()
{
    char szTest[1000] = {0};int i=0,n;
    FILE *fp=fopen("D:\\File1.txt","r");
    //FILE *fout=fopen("D:\\File2.txt","w");
    if(fp == NULL)
    {
        printf("ERROR!\n");
        exit(0);
    }
    //fscanf(fp,"Processesum=%d\n",%n);
    while(!feof(fp))  
    {
        fscanf(fp,"%d%d%d",&Processes[i].id,&Processes[i].arrtime,&Processes[i].reqtime);  //fscanf()函数将数据读入
        printf("\n%3d%12d%15d\n",Processes[i].id,Processes[i].arrtime,Processes[i].reqtime);  //输出到屏幕
        itoa(Processes[i].id,Processes[i].name,10);
        i++;
        /*memset(szTest, 0, sizeof(szTest));
        fscanf(fp,"@id=%d|",&i);
        fgets(fp,"name=%s|",Processes[i].name);
        fscanf(fp,"arrtime=%d|reqtime=%d\n",&Processes[i].arrtime,&Processes[i].reqtime);
        */
    //fscanf(fp,"%d",)
    }
    sumProcess=i;
    fclose(fp);
}
void shuru()
{
    int i;
    printf("作业个数:\n");
    scanf("%d",&sumProcess);
    for(i=1;i<=sumProcess;i++)
    {
        printf("\n第%d个作业:\n",i);
        getchar();
        printf("输入作业名:\n");
        gets(Processes[i].name);
        printf("到达时间:\n");
        scanf("%d",&Processes[i].arrtime);
        printf("要求服务时间:\n");
        scanf("%d",&Processes[i].reqtime);
    }
    sumofthey();
}
void choosesort()
{
    int n;
    printf("\t\t\t*****************************\n");
    printf("\t\t\t*******1.FCFS算法调度********\n");
    printf("\t\t\t*******2.SJF算法调度*********\n");
    printf("\t\t\t*******3.HRRF算法调度********\n");
    printf("\t\t\t*******4.调用系统清屏********\n");
    printf("\t\t\t*******5.退出算法调度********\n");
    printf("\t\t\t*****************************\n");
    scanf("%d",&n);
    switch(n)
    {
    case 1:
        printf("运行先来先服务算法FCFS\n");
        sort(1);
        printf("\n经按到达时间排序后，未达到队列是\n");
        printz();
        break;
    case 2:
        printf("运行最短作业优先算法FJS\n");
        sort(2);
        printf("\n经按到达时间排序后，未达到队列是\n");
        printz();
        break;
    case 3:
        printf("运行最高响应比优先算法HRRF\n");
        sort(3);
        printf("\n经按到达时间排序后，未达到队列是\n");
        printz();
        break;
    case 4:
        system("cls");
        break;
    case 5:
        exit(0);
        break;
    }
}
void main()
{
    startit();
//    choosesort();
    while(sumProcess!=0)
    {
        RunProcess();
    }

}