操作系统中先来先服务、短作业优先、最高相应比优先三个进程数组实现的算法

一、先来先服务和短作业（进程）优先调度算法

  1. 先来先服务调度算法。先来先服务（FCFS）调度算法是一种最简单的调度算法，该算法既可用于作业调度， 也可用于进程调度。FCFS算法比较有利于长作业（进程），而不利于短作业（进程）。由此可知，本算法适合于CPU繁忙型作业， 而不利于I/O繁忙型的作业（进程）。
  2. 短作业（进程）优先调度算法。短作业（进程）优先调度算法（SJ/PF）是指对短作业或短进程优先调度的算法，该算法既可用于作业调度， 也可用于进程调度。但其对长作业不利；不能保证紧迫性作业（进程）被及时处理；作业的长短只是被估算出来的。

二、高优先权优先调度算法

  1. 优先权调度算法的类型。为了照顾紧迫性作业，使之进入系统后便获得优先处理，引入了最高优先权优先（FPF）调度算法。 此算法常被用在批处理系统中，作为作业调度算法，也作为多种操作系统中的进程调度，还可以用于实时系统中。当其用于作业调度，将后备队列中若干个优先权最高的作业装入内存。当其用于进程调度时，把处理机分配给就绪队列中优先权最高的进程，此时，又可以进一步把该算法分成以下两种：
    1)非抢占式优先权算法
   2)抢占式优先权调度算法（高性能计算机操作系统）
  2. 优先权类型 。对于最高优先权优先调度算法，其核心在于：它是使用静态优先权还是动态优先权，以及如何确定进程的优先权。
  3. 高响应比优先调度算法
    为了弥补短作业优先算法的不足，我们引入动态优先权，使作业的优先等级随着等待时间的增加而以速率a提高。 该优先权变化规律可描述为：优先权=（等待时间+要求服务时间）/要求服务时间；即 =（响应时间）/要求服务时间

下面是代码部分：

/**

   操作系统中关于先来先服务、短作业优先、最高响应比优先的程序实现

*/

#include

#define N 5

void main()

{

         inta[2][5]={0};  //a[0][i]存放到达的时间，a[1][i]存放需要的服务时间

         intd[5]={0};

         inth[5]={0,1,2,3,4};

         doubleb[4][6]={0};  //FCFS

         doublen[4][6]={0};  //SJF

         doublem[4][6]={0};  //最高相应比优先

         doublec[5];    //存放响应比

         doubleha[5];   //存放服务时间用于响应比排序

         inti=0,j=0,t;

         inttemp;

         intr,z;

         printf("五个进程:\tA\tB\tC\tD\tE\n");

   printf("到达时间:\t");

         for(i=0;i

         {  

                   a[0][i]=i;     //到达时间

                   printf("%d\t",a[0][i]);

         }

         printf("\n");

         printf("请输入服务时间:\t");

   for(i=0;i

         {

             scanf("%d",&a[1][i]);  //服务时间

         }

         printf("服务时间:\t");

         for(i=0;i

         {  

                    d[i]=a[1][i];    //把服务时间顺便存放到d数组中

                  printf("%d\t",a[1][i]);

         }

         printf("\n");

   /*先来先服务*/

   printf("FCFS\n");     

   printf("开始时间:\t");

         b[0][0]=a[0][0];

                   printf("%d\t",b[0][0]);

   for(i=1;i

    {

           b[0][i]=b[0][i-1]+(double)(a[1][i-1]);

     printf("%d\t",(int)b[0][i]);//b[0][i]存放的是各进程开始时间

         }

         printf("\n");

         b[1][0]=(double)a[1][0];

   printf("完成时间:\t%d\t",(int)b[1][0]); //b[1][i]存放的是完成时间

   for(i=1;i

    {

           b[1][i]=b[0][i]+(double)a[1][i];

     printf("%d\t",(int)b[1][i]);

         }

         printf("\n");

   printf("周转时间:\t");

   for(i=0;i

    {

     b[2][i]=b[1][i]-(double)a[0][i];

           b[2][5]+=b[2][i];   //b[2][5]周转时间累加和

     printf("%d\t",(int)b[2][i]); //b[2][i]存放的是周转时间

         }

         printf("arve=%.2f\n",b[2][5]/5);

         printf("带权周转时间:\t");

   for(i=0;i

    {

           b[3][i]=b[2][i]/(double)(a[1][i]);

           b[3][5]+=b[3][i];  //b[3][5]带权周转时间累加和

     printf("%.1f\t",(double)b[3][i]);//b[3][i]存放的是带权周转时间

         }

         printf("avre=%.2f\n",b[3][5]/5);

   /*短作业优先*/

   printf("SJF\n"); 

   for(i=1;i

                   for(j=i+1;j

                            if(d[i]>d[j])

                            {

                              t=d[j];

                              d[j]=d[i];

                              d[i]=t;

 

                              temp=h[j];

                              h[j]=h[i];

                              h[i]=temp;

                            }                //h[i]即为进程服务的顺序   for(i=0;i<5;i++)printf("%d\t",h[i]);  

         printf("开始时间:\t");

   for(i=1;i

         {

                   n[0][h[i]]=a[1][h[i-1]]+n[0][h[i-1]];

         }

         for(i=0;i

           printf("%d\t",(int)n[0][i]);

     printf("\n");

         printf("完成时间:\t");

         n[1][0]=a[1][0];

         for(i=1;i

            n[1][h[i]]=n[0][h[i]]+a[1][h[i]];

  for(i=0;i

           printf("%d\t",(int)n[1][i]);

     printf("\n");

       printf("周转时间:\t");

         //n[2][0]=n[1][0]-a[0][0];//刚开始总是先执行第一个来的

         for(i=0;i

            n[2][i]=n[1][i]-a[0][i];

   for(i=0;i

         {

           n[2][5]+=n[2][i];  //总周转时间

           printf("%d\t",(int)n[2][i]);

    }

     printf("avre=%.2f\n",n[2][5]/5);     

   printf("带权周转时间\t");

         for(i=0;i

            n[3][i]=n[2][i]/a[1][i];

  for(i=0;i

  { 

            n[3][5]+=n[3][i];  //总带权周转时间

            printf("%.1f\t",n[3][i]);

   }

     printf("avre=%.2f\n",n[3][5]/5);

   /*最高相应比优先*/

   printf("最高相应比优先:\n");

          for(i=1;i

       {

          ha[i]=a[1][i];//a[1][i]服务时间，ha[i]用于排序找响应比

        }

      m[0][0]=0;  //开始时间

      m[1][0]=a[1][0];

      r=0;

     for(int X=1;X

      {

        for(i=1;i

         {

              if(ha[i]!=0)

                 c[i]=1+(double)(m[1][r]-a[0][i])/a[1][i];//c[i]用于存放响应比

           else

              c[i]=0;

         }

                  z=1;

               for(j=1;j

                     {

                 if(c[z]<=c[j]&&ha[j]!=0)

                  z=j;           

                     }

                 ha[z]=0;

                 m[0][z]=m[1][r]; 

                 m[1][z]=m[0][z]+a[1][z];

                 r=z; 

           }

              printf("开始时间:\t");

        for(i=0;i

             printf("%d\t",(int)m[0][i]);

                    printf("\n");

        printf("完成时间:\t");

        for(i=0;i

             printf("%d\t",(int)m[1][i]);

        printf("\n");

                    printf("周转时间\t");

        for(i=0;i

                    {

                             m[2][i]=m[1][i]-a[0][i];

                             m[2][5]+=m[2][i];  //m[2][5]周转时间累加和

                             printf("%d\t",(int)m[2][i]);

                    }

                    printf("aver=%.2f\n",m[2][5]/5);

                    printf("带权周转时间\t");

        for(i=0;i

                    {

                             m[3][i]=m[2][i]/a[1][i];

                             m[3][5]+=m[3][i];

                             printf("%.1f\t",m[3][i]);

                    }

                    printf("aver:%.2f\n",m[3][5]/5);

}