操作系统进程调度算法——先来先服务、时间片轮转、优先级调度算法 ...

一、先来先服务调度算法

（1）算法内容：先来先服务调度算法是一种最简朴的调度算法，可以应用于高级调度也可以运用于低级调度。高级调度时，FCFS调度算法按照作业进入后备作业队列的先后次序选择作业进入内存，即先进入后备作业队列的作业被优先选择进入内存，然后为选中的作业创建进程并分配该作业所需资源。低级调度时，FCFS调度算法每次从内存的进程/线程就绪队列中选择一个最先进入的进程/线程，然后由进程/线程调度步伐将CPU分配给它并使其运行。
（2）算法要求：每个进程由一个进程控制快（PCB）表现。进程控制块可以包含如下信息：进程名，到达时间，运行时间，开始时间，完成时间，等待时间，周转时间，代权周转时间等。先进入就绪队列的进程，先分配处理处罚机运行。一旦一个进程占据了处理处罚机，它就一直运行下去，直到该进程完成工作大概因为等待某事件发生而不能继续运行时才释放处理处罚机。
（3）设计思想：该算法按照进程到达时间先后次序执行，先到达的先执行。
（4）算法分析：先界说一个PCB布局体；
界说input()输入函数，输入进程号、到达时间、运行时间；
界说output()输出函数，输出每个进程块的各种时间；
界说rank()排序函数，将进程按照到达时间进行排序；
界说FCFS()先来先服务算法函数，计算各种时间；
界说main()主函数，实现先来先服务功能；
（5）焦点代码：

1. #include<stdio.h>
2.     double atime;            //平均周转时间
3.         double awtime;    //平均带权周转时间
4. struct PCB     //声明结构体类型PCB
5. {
6.         char name[20];          //进程号
7.         int arrivaltime;       //到达时间
8.         int runtime;           //运行时间
9.         int starttime;         //开始时间
10.         int finishtime;        //完成时间
11.         int waitingtime;       //等待时间
12.         int cycletime;        //周转时间
13.         double wctime;        //带权周转时间
14. };
15. struct PCB pcb[100];
16. /*输入函数*/
17. int input(int n)   
18. {
19.         printf("请依次输入进程号、到达时间、运行时间：\n");
20.         for(int i=0;i<n;i++)
21.         {
22.                 scanf("%s\t%d\t%d",pcb[i].name,&pcb[i].arrivaltime,&pcb[i].runtime);
23.         }
24. }
25. /*输出函数*/
26. int output(int n)  
27. {
28.         printf("\n======================================================================================================================\n");
29.         printf("进程号 \t到达时间\t运行时间\t开始时间\t完成时间\t等待时间\t周转时间\t带权周转时间\n");
30.         printf("----------------------------------------------------------------------------------------------------------------------\n");
31.         for(int i=0;i<n;i++)
32.         {
33.         printf("%3s\t  %d\t\t   %d\t\t   %d\t\t   %d\t\t   %d\t\t   %d\t\t   %.2lf\n",pcb[i].name,pcb[i].arrivaltime,pcb[i].runtime,pcb[i].starttime,pcb[i].finishtime,pcb[i].waitingtime,pcb[i].cycletime,pcb[i].wctime);
34.         }
35.         printf("----------------------------------------------------------------------------------------------------------------------\n");
36.         printf("\t平均周转时间    \t\t%.2lf\t\n",atime);
37.         printf("----------------------------------------------------------------------------------------------------------------------\n");
38.         printf("\t平均带权周转时间\t\t%.2lf\t\n",awtime);
39.         printf("======================================================================================================================\n");
40. }
41. /*按到达时间进行排序*/
42. int rank(int n)
43. {
44.         struct PCB t;
45.         for(int j=0;j<n-1;j++)  //冒泡法排序
46.         for(int i=0;i<n-1-j;i++)
47.     {
48.             if(pcb[i].arrivaltime>pcb[i+1].arrivaltime)
49.                 {
50.                         t=pcb[i];
51.                         pcb[i]=pcb[i+1];
52.                         pcb[i+1]=t;
53.                 }
54.         }
55. }
56. /*先来先服务算法*/
57. int FCFS(int n)
58. {
59. /*完成时间*/
60.         if(pcb[0].arrivaltime!=0) //第一个进程到达时间不为0时，其完成时间=开始时间+运行时间
61.         {
62.                 pcb[0].finishtime=pcb[0].starttime+pcb[0].runtime;
63.         }
64.         else
65.                 pcb[0].finishtime=pcb[0].runtime; //第一个进程到达时间为0时，其完成时间=运行时间
66.                 for(int i=1;i<n;i++)
67.                 {
68.                         if(pcb[i-1].finishtime>=pcb[i].arrivaltime) //如果前一个进程的完成时间大于等于当前进程的到达时间
69.                         {
70.                                 pcb[i].finishtime=pcb[i-1].finishtime+pcb[i].runtime; //当前进程的完成时间=前一个进程的完成时间+该进程的运行时间
71.                          }
72.                         else
73.                         {
74.                                 pcb[i].finishtime=pcb[i].arrivaltime+pcb[i].runtime; //否则为当前进程的到达时间+运行时间
75.                         }
76.                  }
77. /*开始时间*/
78.         pcb[0].starttime=pcb[0].arrivaltime; //第一个进程的开始时间即到达时间
79.         for(int i=1;i<n;i++)
80.         {
81.                 pcb[i].starttime=pcb[i-1].finishtime; //从第二个进程开始，开始时间=前一个进程的完成时间
82.         }
83. /*等待时间 周转时间 带权周转时间*/
84.         for(int i=0;i<n;i++)
85.         {
86.                 pcb[i].waitingtime=pcb[i].starttime-pcb[i].arrivaltime; //等待时间=开始时间-到达时间
87. pcb[i].cycletime=pcb[i].finishtime-pcb[i].arrivaltime; //周转时间=完成时间-到达时间
88. pcb[i].wctime=pcb[i].cycletime/(pcb[i].runtime*1.0); //带权周转时间=周转时间/运行时间
89.          }
90. /*平均周转时间 平均带权周转时间*/
91. int sum1=0;
92. double sum2=0;
93. for(int i=0;i<n;i++)
94.                 {
95.                         sum1+=pcb[i].cycletime;    //求所有进程周转时间的和
96. sum2+=pcb[i].wctime;      //求有所进程周转时间的和
97.                 }
98.                 atime=sum1/(n*1.0);   //平均周转时间=所有进程周转时间的和/进程数
99. awtime=sum2/n;       //平均带权周转时间=所有进程周转时间的和/进程数
100.         }
101.         /*主函数*/
102. int main()
103. {
104.         printf("先来先服务FCFS算法模拟\n请输入进程个数：\n");
105.     int n;
106.     scanf("%d",&n);  //输入进程数 n
107. input(n);       //输入函数
108. rank(n);        //排序函数，按到达时间给各进程排序 （升序）
109.     FCFS(n);         //先来先服务算法函数，计算各种时间
110.     output(n);       //输出函数
111.     return 0;
112. }

复制代码

（6）测试数据或截图：

 （6）运行效果分析：根据先来先服务算法，首先按到达时间巨细将其排序，根据进程的输入信息，第一个进程a到达时间为0，其完成时间=运行时间=1，别的进程的完成时间=前一个进程的完成时间+该进程的运行时间，（如，b的完成时间=1+100=101，c的完成时间=101+1=102，d的完成时间=102+100=201）；第一个进程a的开始时间=到达时间=0，别的进程的开始时间=前一个进程的完成时间，（如，b的开始时间=a的完成时间=1，c的开始时间=b的完成时间=101，d的开始时间=c的完成时间=102）；每个进程的等待时间=开始时间-到达时间（如，a的等待时间=0-0=0，b的等待时间=1-1=0，c的等待时间=101-2=99，d的等待时间=102-3=99）；周转时间=完成时间-到达时间（如，a的周转时间=1-0=1，b的周转时间=101-1=100，c的周转时间=102-2=100，d的周转时间=202-3=199）；带权周转时间=周转时间/运行时间（如，a的带权周转时间=1/1=1，b的带权周转时间=100/100=1，c的带权周转时间=100/1=100，d的带权周转时间=199/100=1.99）；均匀周转时间=所有进程周转时间的和/进程数(1+100+100+199)/4=100；均匀带权周转时间=所有进程带权周转时间的和/进程数（1+1+100+1.99）/4=26。
二、时间片轮转调度算法

（1）算法内容：时间片轮转调度算法主要用于低级调度，调度方式现实上是一种基于时钟的抢占式调度算法。在采用时间片轮转调度算法的系统中，进程/线程就绪队列按到达时间的先后次序进行排队，按照先来先服务原则，将需要执行的所有进程按照到达时间巨细排成一个升序的序列，每次都给一个进程同样巨细的时间片，在这个时间片内如果进程执行结束了，那么把进程从进程队列中删去，如果进程没有结束，那么把该进程克制然后改成等待状态，放到进程队列的尾部，直到所有的进程都已执行完毕。
（2）算法要求：每个进程由一个进程控制块（PCB）表现。进程控制块可以包含如下信息：进程名，到达时间，运行时间，完成时间，周转时间，带权周转时间，完成进程标记，剩余服务时间等。进程的运行时间以时间片为单位进行计算。
（3）设计思想：每次调度时，总是选择就绪队列的队首进程，让其在CPU上运行一个系统预先设置好的时间片。一个时间片内没有完成运行的进程，返回到绪队列末尾重新排队，等待下一次调度。时间片轮转调度属于抢占式调度，适用于分时系统。
（4）算法分析：先界说一个RR布局体；
input()输入函数；
rank()函数对进程到达时间排序；
rr_pcb()函数执行轮转调度算法；
output()输出函数；
main()主函数。
（5）焦点代码：

1. #include<stdio.h>
2.    double atime;            //平均周转时间
3.    double awtime;    //平均带权周转时间
4. struct RR
5. {
6.         char name[20];         //进程号
7.         int arrivaltime;       //到达时间
8.         int runtime;           //运行时间
9.         int starttime;         //开始时间
10.         int finishtime;        //完成时间
11.         int cycletime;      //周转时间
12.         double wctime;      //带权周转时间
13.         int sign;          //完成进程标志
14.         int st1;    //剩余服务时间
15.   };
16.   struct RR rr[100];
17.   /*输入函数*/
18. int input(int n)
19. {
20.         printf("请依次输入进程号、到达时间、运行时间：\n");
21.         for(int i=0;i<n;i++)
22.         {
23.                 rr[i].sign=0;
24.                 scanf("%s\t%d\t%d",rr[i].name,&rr[i].arrivaltime,&rr[i].runtime);
25.                 rr[i].st1=rr[i].runtime;
26.         }
27. }
28. /*采用冒泡法，按进程的到达时间对进程进行排序*/
29. int rank(int n)
30. {
31.         int i,j;
32.         struct RR temp;
33.         for(j=0;j<n-1;j++)
34.         for(i=0;i<n-1-j;i++)
35.         {
36.                 if(rr[i].arrivaltime>rr[i+1].arrivaltime)
37.                 {
38.                         temp=rr[i];
39.                         rr[i]=rr[i+1];
40.                         rr[i+1]=temp;
41.                 }
42.         }
43. }
44. /*执行时间片轮转调度算法*/
45. int rr_pcb(int n)  
46. {
47.         printf("请输入时间片：\n");
48.         int t;
49.         scanf("%d",&t);  //输入时间片
50.         int time=rr[0].arrivaltime;     //给当前时间time赋初值
51.         int flag=1;          //标志就绪队列中有进程
52.         int sum=0;          //记录完成的进程数
53.         printf("\n====================================================================================================================\n");
54.         printf("进程号 \t到达时间\t运行时间\t开始时间\t完成时间\t周转时间\t带权周转时间\n");
55.         printf("--------------------------------------------------------------------------------------------------------------------\n");
56.         while(sum<n) //当完成的进程数小于进程总数
57.         {
58.         flag=0;    //标记就绪队列没有进程
59.         for(int i=0;i<n;i++) //时间片轮转法执行各进程
60.         {
61.                 if(rr[i].sign==1)//已完成进程
62.                 continue;
63.                 else//未完成的进程
64.                 {
65.                         if(rr[i].st1<=t && time>=rr[i].arrivaltime)//还需运行的时间小于等于一个时间片
66.                         {
67.                        flag=1;  //把进程加入到就绪队列中
68.                          time+=rr[i].st1;
69.                        rr[i].sign=1; //此进程完成
70.                   rr[i].finishtime=time;  //完成时间
71.               rr[i].cycletime=rr[i].finishtime-rr[i].arrivaltime;  //计算周转时间=完成时间-到达时间
72.                           rr[i].wctime=rr[i].cycletime/(rr[i].runtime*1.0);   //计算带权周转时间=周转时间/服务
73.                           printf("%3s\t  %d\t\t   %d\t\t   %d\t\t   %d\t\t   %d\t\t   %.2lf\n",rr[i].name,
74.         rr[i].arrivaltime,rr[i].runtime,time-rr[i].st1,time,rr[i].cycletime,rr[i].wctime);
75.                         }                             
76.                         else if(rr[i].st1>t&&time>=rr[i].arrivaltime)    //还需服务时间至少大于一个时间片
77.                         {
78.                            flag=1;  //把进程加入到就绪队列中
79.                            time+=t;
80.                           rr[i].st1-=t;
81.               rr[i].cycletime=rr[i].finishtime-rr[i].arrivaltime; //计算周转时间=完成时间-到达时间
82.                           rr[i].wctime=rr[i].cycletime/(rr[i].runtime*1.0);  //计算带权周转时间=周转时间/服务
83.                           printf("%3s\t  %d\t\t   %d\t\t   %d\t\t   %d\t\t   %d\t\t   %.2lf\n",rr[i].name,
84.         rr[i].arrivaltime,rr[i].runtime,time-t,time,rr[i].cycletime,rr[i].wctime);
85.                         }
86.                     if(rr[i].sign==1)
87.                        sum++;     //一个进程执行完就+1
88.                 }
89.          }
90.         }
91.         /*平均周转时间  平均带权周转时间*/
92.         int sum1=0;
93.         double sum2=0;
94.         for(int i=0;i<n;i++)
95.         {
96.                
97.                 sum1+=rr[i].cycletime;  //求所有进程周转时间的和
98.                 sum2+=rr[i].wctime;  //求所有进程带权周转时间的和
99.         }
100.         atime=sum1/(n*1.0);  //平均周转时间=有进程周转时间的和/进程数
101.         awtime=sum2/n;   //平均带权周转时间=所有进程带权周转时间的和/进程数
102. }
103. /*输出函数*/
104. int output(int n)
105. {
106.     printf("--------------------------------------------------------------------------------------------------------------------\n");
107.         printf("\t平均周转时间    \t\t%.2lf\t\n",atime);
108.         printf("--------------------------------------------------------------------------------------------------------------------\n");
109.         printf("\t平均带权周转时间\t\t%.2lf\t\n",awtime);
110.         printf("====================================================================================================================\n");
111. }
112. /*主函数*/
113. int main()
114. {
115.         printf("时间片轮转调度算法\n请输入总进程数：\n");
116.         int n;
117.         scanf("%d",&n);   //输入总进程数
118.         input(n);   //输入函数
119.         rank(n);    //排序函数
120.         rr_pcb(n);   //计算各时间
121.         output(n);   //输出函数
122.         return 0;
123. }

复制代码

（6）测试数据或截图：（时间片为1的见图1，时间片为5的见图2）

图1 时间片=1时运行效果截图

图2 时间片=5时运行效果截图

（7）运行效果分析：执行时间图像如下，

图4-24 执行时间图像

时间片=1时，a、b、c、d四个进程的运行时间都大于规定的时间片，一个时间片内没有完成运行，则都需要返回就绪队列的队尾，等待下一次调度继续执行。CPU被分配给当前就绪队列的第一个进程。
时间片=5时，第一个进程的运行时间等于20>5，一个时间片内没有完成运行，则进程a返回到就绪队列末尾重新排队，等待下一次调度；第二个进程的运行时间等于10>5，用完了规定的时间片，则进程b返回到绪队列末尾，等待再次被调度执行；第二个进程的运行时间等于15>5，则进程c返回到就绪队列的队尾，等到下一次轮转到自己时再投入运行；第四个进程的运行时间为5，刚幸亏一个时间片内完成运行，则进程d放弃CPU的使用权。此时，进程调度步伐又将CPU分配给当前就绪队列的第一个进程，即进程a。
三、优先级调度算法

（1）算法内容：优先级调度算法既可以应用于高级调度（作业调度）也可以应用于低级调度（进程调度），还可用于实时系统。高级调度时，优先数调度算法每次从后备作业队列中选择优先级最高的作业调入内存，为其分配相应的资源并创建进程放入到进程就绪队列中。低级调度时，优先级调度算法每次从进程就绪队列中选择优先级最高的进程为其分配CPU而投入运行。如果有多个优先级最高的作业/进程，则可结合先来先服务或短作业/短进程优先调度策略。
（2）算法要求：每个进程由一个进程控制块（PCB）表现。进程控制块可以包含如下信息：进程名，运行时间，优先数，进程状态等。进程的优先数及需要运行时间可以事先人为指定（也可由随机数产生）。每个进程的状态可以是就绪W（Wait）,运行R（Run）大概完成F（Finish）3个状态之一。
（3）设计思想：采用抢占式优先级调度算法，具有最高级优先级的就绪进程/线程首先得到CPU运行，并在运行过程中允许被具有更高优先级的就绪进程/线程抢占CPU。如果有多个优先级最高的进程，则结合先来先服务调度策略。每次运行之前，为每个进程恣意确定它的“优先数”和“要求运行时间”。处理处罚器总是选队首进程运行。采用动态改变优先数的办法，进程每运行1次，优先数减1，要求运行时间减1。进程运行一次后，若要求运行时间不等于0，则将它加入队列，否则，将状态改为“结束”，退出队列。若就绪队列为空，结束，否则重复上述步调。
（4）算法分析：界说进程控制块；
input()函数;
output()函数；
max_priority()函数找出就绪态中优先级最高的进程；
psa_pcb()函数为优先级调度算法；
main()主函数；
（5）焦点代码：

1. #include<stdio.h>
2. /*结构体*/
3. struct PSA
4. {
5. char name[10];      //进程名
6. int runtime;       //运行时间
7. int priority;      //优先数
8. char state;        //状态，三状态：W-就绪；R-运行；F-结束
9. };
10. struct PSA psa[10];   //定义进程控制块数组
12. /*输入函数*/
13. int input(int n)
14. {
15. printf("请输入PCB的进程名，运行时间，优先数:\n");
16. for(int i=0;i<n;i++)    //i为进程编号
17. {
18. scanf("%s\t%d\t%d",&psa[i].name,&psa[i].runtime,&psa[i].priority);
19. psa[i].state=‘W’;    //初始状态都设为就绪
20. getchar();
21. }
22. }
23. /*输出函数*/
24. int output(int n)
25. {
26. printf("\n==============================\n");
27. printf("进程号 运行时间 优先数 状态\n");
28. printf("------------------------------\n");
29. for(int i=0;i<n;i++)
30. printf("%s %7d%9d\t%s\n",psa[i].name,psa[i].runtime,psa[i].priority,&psa[i].state);
31. printf("==============================\n");
32. }
33. /*进程在就绪状态时找出最大优先数进程（返回值为最大优先数编号）*/
34. int max_priority(int n)
35. {
36. int max=-1;    //max为最大优先数
37. int m;     //m为最大优先数进程的编号
38. for(int i=0;i<n;i++)
39. {      //进程在就绪状态时找出最大优先数
40. if(psa[i].state==‘R’)    //进程在运行状态
41. return -1;
42. else if((max<psa[i].priority)&&(psa[i].state==‘W’)) //进程在就绪状态
43. {
44. max=psa[i].priority;
45. m=i;     //把最大优先数对应的编号赋给m
46. }
47. }
48. //确保最大优先数进程还没结束运行
49. if(psa[m].state==‘F’) //最大优先数进程已结束运行
50. return -1;
51. else //最大优先数进程还没结束运行
52. return m; //返回值为最大优先数编号
53. }
54. /*优先数调度算法*/
55. int psa_pcb(int n)
56. {
57. int max_time=-1,m=0;
58. int sum=0;    //sum为程序总运行次数
59. for(int i=0;i<n;i++)
60. sum+=psa[i].runtime;
61. printf("\n初始时各进程信息如下:\n");
62. output(n);
63. getchar();
64. for(int j=0;j<sum;j++)
65. {
66. //当程序正在运行时
67. while(max_priority(n)!=-1)    //max_priority ()为找出最大优先数进程函数，返回最大值对应的编号m
68. {
69. if(psa[max_priority(n)].priority!=0)
70. psa[max_priority(n)].state=‘R’;    //由就绪转为运行态
71. else
72. { //当优先级降为0，进程还没运行完时
73. for(int i=0;i<n;i++)
74. if(max_time<psa[i].runtime)
75. {
76. max_time=psa[i].runtime;
77. m=i;    //返回对应的编号
78. }
79. max_time=-1;
80. psa[m].state=‘R’;    //状态转为运行态
81. }
82. }
83.     //判断程序状态(对优先数和运行时间操作)
84.     for(int i=0;i<n;i++)
85.     {
86.         if(psa[i].state==‘R’)   //当进程处于运行状态时
87.         {
88.             if(psa[i].priority>0)     //优先数>0
89.                psa[i].priority--;  //每运行一次优先数-1
90.             psa[i].runtime--;   //每运行一次运行时间-1
91.         }
92.         if(psa[i].runtime==0)  //运行时间完
93.                         psa[i].state=‘F’;   //进程状态转为完成状态
94.         else     //运行时间没完
95.                         psa[i].state=‘W’;   //进程状态转为就绪状态
96.     }
97.     output(n);
98.     getchar();
99. }   
100. }
101. /*主函数*/
102. int main()
103. {
104.         printf("优先数调度算法：\n输入总进程数：\n");
105.         int n;
106.         scanf("%d",&n);   //输入总进程数n
107.     input(n);    //输入函数
108.     psa_pcb(n);   //优先数调度算法
109.     return 0;
110. }

复制代码

 
（6）测试数据或截图：

  

 

（7）运行效果分析：初始时，a、b、c、d、e五个进程的状态都是就绪态（W），其中c的优先级最大，则c首先得到CPU运行，其运行时间为2，在运行状态时运行时间减1，优先数减1；进程a的运行时间为0，此时a的状态由就绪态变为完成态；之后c、e的优先数都是最大的，但根据先来先服务调度策略，c先处于运行态，优先数减1，运行时间减1为0，所以c变成完成态；此时只有b、d、e三个进程处于就绪态，其中e的优先数最大，则e获得CPU投入运行，其运行时间减1，优先数减1；然后b和e的优先数都一样大，根据先来先服务调度策略，则b抢占CPU处于运行态，运行时间减1为0，则b变成完成态；此时只剩下d和e两个进程，e的优先数较大，则e抢占CPU处于运行态，优先数和运行时间减1；e优先数减1后与d的一样大，但根据先来先服务原则，d先获得CPU，处于运行态，优先数和运行时间减1；此刻，e的优先数比d大，故e得到CPU运行，运行时间和优先数减1；d和e的优先数又是一样大，但d先运行，运行时间和优先数减1，则e优先数大于d，e获得CPU，运行时间减1为0，e处于完成态；最后只剩d获得CPU运行，运行时间减1为0，变成完成态。总之，优先级高的进程先获得CPU处于运行态，运行一次后，运行时间与优先数减1,当运行时间不为0时加入就绪队列，运行时等于0时状态改为结束（F）。如果有多个优先级一样高的进程，则根据先来先服务原则处理处罚。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。