《操作系统》 先来先服务FCFS和短作业优先SJF进程调度算法相关计算及实验

操作系统系列

  学习至此，发现很多学了但很久没用的知识，久而久之，慢慢遗忘。等哪天还需要的话，却发现已经忘得差不多了，即使整理了文档（word等），还是得从头再学一遍。读研第一学期，发现很多东西都可以从博客上学习到，也有不少博主呕心沥血整理了挺多有用的博文。于是，本人借此契机，也慢慢开始整理一些博文，不断改进完善中。整理博文（IT）有如下目的：

• 首要目的：记录“求学生涯”的所学所悟，不断修改，不断更新！（有读者的互动）
• 其次目的：在这“开源”的时代，整理并分享所学所悟是一种互利的行为！

博文系列：操作系统课程的相关实验

• 1.先来先服务FCFS和短作业优先SJF进程调度算法
  
• 2.时间片轮转RR进程调度算法
  
• 3.预防进程死锁的银行家算法
  
• 4.动态分区分配算法
  
• 5.虚拟内存页面置换算法
  
• 6.磁盘调度算法

6个实验相关的代码下载地址：http://download.csdn.net/detail/houchaoqun_xmu/9865648

-------------------------------

先来先服务FCFS和短作业优先SJF进程调度算法

一、概念介绍和案例解析

  FCFS调度算法

  先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。

周转时间=作业完成时刻—作业到达时刻；

带权周转时间=周转时间/服务时间；

平均周转时间=作业周转总时间/作业个数；

平均带权周转时间=带权周转总时间/作业个数；

• 案例剖析：

  FCFS算法比较有利于长作业(进程)，而不利于短作业(进程)。下表列出了A、B、C、D四个作业分别到达系统的时间、要求服务的时间、开始执行的时间及各自的完成时间，并计算出各自的周转时间和带权周转时间。

  从表上可以看出，其中短作业C的带权周转时间竞高达100，这是不能容忍的；而长作业D的带权周转时间仅为1.99。据此可知，FCFS调度算法有利于CPU繁忙型的作业，而不利于I/O繁忙型的作业(进程)。

  CPU繁忙型作业是指该类作业需要大量的CPU时间进行计算，而很少请求I/O。通常的科学计算便属于CPU繁忙型作业。

  I/O繁忙型作业是指CPU进行处理时需频繁地请求I/O。目前的大多数事务处理都属于I/O繁忙型作业。

• 案例剖析2：采用FCFS调度算法时的调度性能

  上图表示出有五个进程A、B、C、D、E，它们到达的时间分别是0、1、2、3和4，所要求的服务时间分别是4、3、5、2和4，其完成时间分别是4、7、12、14和18。从每个进程的完成时间中减去其到达时间，即得到其周转时间，进而可以算出每个进程的带权周转时间。

• SJF调度算法：

  短作业(进程)优先调度算法SJ(P)F，是指对短作业或短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。而短进程优先(SPF)调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。

  为了和FCFS调度算法进行比较，我们仍利用FCFS算法中所使用的实例，并改用SJ(P)F算法重新调度，再进行性能分析。由上图中的(a)和(b)可以看出，采用SJ(P)F算法后，不论是平均周转时间还是平均带权周转时间，都有较明显的改善，尤其是对短作业D，其周转时间由原来的(用FCFS算法时)11降为3；而平均带权周转时间是从5.5降到1.5。这说明SJF调度算法能有效地降低作业的平均等待时间，提高系统吞吐量。

  SJ(P)F调度算法也存在不容忽视的缺点：

1. 该算法对长作业不利，如作业C的周转时间由10增至16，其带权周转时间由2增至3.1。更严重的是，如果有一长作业(进程)进入系统的后备队列(就绪队列)，由于调度程序总是优先调度那些(即使是后进来的)短作业(进程)，将导致长作业(进程)长期不被调度。
   
2. 该算法完全未考虑作业的紧迫程度，因而不能保证紧迫性作业(进程)会被及时处理。
   
3. 由于作业(进程)的长短只是根据用户所提供的估计执行时间而定的，而用户又可能会有意或无意地缩短其作业的估计运行时间，致使该算法不一定能真正做到短作业优先调度。
   

二、实验介绍

• 问题描述：

  设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T₁,… ,T_n时刻到达系统，它们需要的服务时间分别为S₁,… ,S_n。分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度，计算每个进程的完成时间、周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。

• 程序要求：

---- 进程个数n；每个进程的到达时间T₁, … ,T_n和服务时间S₁, … ,S_n；选择算法1-FCFS，2-SJF。

---- 要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行，计算每个进程的周转时间和带权周转时间，并且计算所有进程的平均周转时间和带权平均周转时间。

---- 输出：要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程B开始运行”等等。

---- 输出：要求输出计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。

三、程序设计和开发

• 程序设计：

1. Initial()进行初始化。
2. input()对到达时间和服务时间进行输入。
3. get_firstProcess()获得第一个进程，FCFS和SJF算法的实现相同。
4. FCFS()对算法进行处理。
5. SJF()对算法进行处理。
6. choose_Algorithm();对实现算法的类别进行选择：具有容错性特征。

• FCFS：

[cpp] view plain copy

1. void FCFS()  
2. {  
3.     /* 
4.         1. 找到最先到达的进程的坐标，并计算相关信息 
5.         2. 依次找到接下去到达的进程 
6.     */  
7.   
8.     int startWorkTime = 0;  //表示开始执行时间 = 当前进程之前的所有服务时间之和  
9.     int first = get_firstProcess();  //获得第一个进程  
10.   
11.     isFinished_FCFS[first] = true;  
12.     FinishTime[first] = ArrivalTime[first] + ServiceTime[first];  
13.     startWorkTime += ServiceTime[first];   //下一个进程的开始执行时间  
14.     WholeTime[first] = FinishTime[first] - ArrivalTime[first];   //周转时间 = 完成时间 - 到达时间  
15.     WeightWholeTime[first] = WholeTime[first]/ServiceTime[first]; //带权周转时间 = 周转时间/服务时间  
16.   
17.     //接下去的进程  
18.     int nextProcess = n; //初始化下一个进程的下标超出界限  
19.   
20.     for (int i=1;i<n;i++)  
21.     {  
22.         nextProcess = n;  //每次对下一个进程的下标进行更新  
23.         for (int j=0;j<n;j++)  
24.         {  
25.             if (!isFinished_FCFS[j])  //表示当前进程还未完成相关信息的计算  
26.             {  
27.                 if (ArrivalTime[j]<=startWorkTime)  //满足到达时间小于等于开始执行时间的情况下  
28.                 {  
29.                     if (nextProcess==n)  
30.                     {  
31.                         nextProcess = j;  
32.                     }  
33.                     else  
34.                     {  
35.                         if (ArrivalTime[nextProcess]>ArrivalTime[j])  //筛选出最先到达的进程  
36.                         {  
37.                             nextProcess=j;    //获得当前进程中：最先到达的进程  
38.                         }  
39.                     }  
40.                 }  
41.             }  
42.         }//for(j)  
43.         //获得当前需要处理的进程nextProcess后，对相关信息进行计算  
44.         isFinished_FCFS[nextProcess] = true;  
45.         FinishTime[nextProcess] = ServiceTime[nextProcess] + startWorkTime;  
46.         startWorkTime += ServiceTime[nextProcess];  //获得下一个进程对应的“开始执行时间”  
47.         WholeTime[nextProcess] = FinishTime[nextProcess] - ArrivalTime[nextProcess];  
48.         WeightWholeTime[nextProcess] = (double)WholeTime[nextProcess]/ServiceTime[nextProcess];  
49.   
50.     }//for(i)  
51.   
52.     //计算平均周转时间和平均带权周转时间  
53.     double totalWT = 0;  
54.     double totalWWT = 0;  
55.     for (int i=0;i<n;i++)  
56.     {  
57.         totalWT+=WholeTime[i];  
58.         totalWWT+=WeightWholeTime[i];  
59.     }  
60.     AverageWT_FCFS = totalWT/n;  
61.     AverageWWT_FCFS = totalWWT/n;  
62.   
63.     //输出检测  
64.     display();  
65.     cout<<"平均周转时间="<<AverageWT_FCFS<<endl;  
66.     cout<<"平均带权周转时间="<<AverageWWT_FCFS<<endl;  
67.     cout<<"******************************************************"<<endl;  
68. }  

• SJF：

[cpp] view plain copy

1. void SJF()  
2. {  
3.     //与SCSF类似，相同的方法获得第一个进程  
4.     int startWorkTime_SJF = 0;  //表示开始执行时间 = 当前进程之前的所有服务时间之和  
5.     //第一个进程的处理  
6.     int first = get_firstProcess();  //获得第一个进程  
7.   
8.     isFinished_SJF[first] = true;  
9.     FinishTime[first] = ArrivalTime[first] + ServiceTime[first];  
10.     startWorkTime_SJF += ServiceTime[first];   //下一个进程的开始执行时间  
11.     WholeTime[first] = FinishTime[first] - ArrivalTime[first];   //周转时间 = 完成时间 - 到达时间  
12.     WeightWholeTime[first] = (double)WholeTime[first]/ServiceTime[first]; //带权周转时间 = 周转时间/服务时间  
13.   
14.     //获得下一个进程的下标  
15.       
16.     int nextProcess_SJF = n;  
17.     for (int i=1;i<n;i++)  
18.     {  
19.         nextProcess_SJF = n;  
20.         for (int j=0;j<n;j++)  
21.         {  
22.             if (!isFinished_SJF[j])  
23.             {  
24.                 if (ArrivalTime[j]<=startWorkTime_SJF)  
25.                 {  
26.                     if (nextProcess_SJF==n)  
27.                     {  
28.                         nextProcess_SJF = j;  
29.                     }  
30.                     else  
31.                     {  
32.                         if (ServiceTime[nextProcess_SJF]>ServiceTime[j])  
33.                         {  
34.                             nextProcess_SJF = j;   //获得运行时间最短的作业的下标  
35.                         }  
36.                     }  
37.                 }  
38.             }  
39.         }//for(j)  
40.           
41.         //对获得的进程进行处理  
42.         isFinished_SJF[nextProcess_SJF] = true;  
43.         FinishTime[nextProcess_SJF] = ServiceTime[nextProcess_SJF] + startWorkTime_SJF;  
44.         startWorkTime_SJF += ServiceTime[nextProcess_SJF];   
45.         WholeTime[nextProcess_SJF] = FinishTime[nextProcess_SJF] - ArrivalTime[nextProcess_SJF];  
46.         WeightWholeTime[nextProcess_SJF] = (double)WholeTime[nextProcess_SJF]/ServiceTime[nextProcess_SJF];  
47.   
48.     }//for(i)  
49.   
50.     double totalWT = 0;  
51.     double totalWWT = 0;  
52.     for (int i=0;i<n;i++)  
53.     {  
54.         totalWT+=WholeTime[i];  
55.         totalWWT+=WeightWholeTime[i];  
56.     }  
57.     AverageWT_SJF = totalWT/n;  
58.     AverageWWT_SJF = totalWWT/n;  
59.   
60.     //输出检测  
61.     display();  
62.     cout<<"平均周转时间="<<AverageWT_SJF<<endl;  
63.     cout<<"平均带权周转时间="<<AverageWWT_SJF<<endl;  
64.     cout<<"******************************************************"<<endl;  
65. }  

四、实验结果分析

-- 输入数据：

-- 进程数n = 5

-- 到达时间：0 1 2 3 4

-- 服务时间：4 3 5 2 4

• FCFS算法：

• SJF算法：

五、实验源码

[cpp] view plain copy

1. // 操作系统_实验一.cpp : 定义控制台应用程序的入口点。  
2. //  
3. /* 
4. //实验题目：先来先服务FCFS和短作业优先SJF进程调度算法 
5. *******概念******* 
6. 1. 先来先服务FCFS： 
7. 2. 短作业优先SJF： 
8. 3. 高级调度：根据某种算法，在外存中把处于后备队列中的那些作业调入内存，当作业完成时做善后处理 
9. 4. 中级调度 
10. 5. 低级调度：对象是进程（或内核级线程）；三个基本机制：排队器、分派器、上下文切换机制 
11. 6. 调度方式和算法的若干准则 
12.     1）面向用户的准则：周期时间短、响应时间快、截止时间的保证、优先权准则 
13.     2）面向系统的准则：系统吞吐量高、处理机利用率好、各类资源的平衡利用 
14. 7. 调度算法：根据系统的资源分配策略所规定的资源分配算法 
15. 8. FCFS调度算法有利于CPU繁忙型的作业，而不利于I/O繁忙型的作业或进程 
16.  
17. *******实验要求********* 
18. 1. 先来先服务调度算法FCFS： 
19.     1）是一种最简单的调度算法，适用于作业调度和进程调度 
20.     2）每次调度都是从后备队列中选择一个或者多个最先进入该队列的作业，将它们调入内存，分配资源，创建进程，然后放入就绪队列 
21.     3）FCFS算法比较有利于长作业（进程），不利于短作业（进程） 
22.     4）既可用于作业调度，也可用于进程调度 
23. 2. 周转时间 = 完成时间 - 到达时间 
24.    带权周转时间 = 周转时间/服务时间 
25.  
26. */  
27.   
28. #include <iostream>  
29. #include <iomanip>  
30. using namespace std;  
31.   
32. #define MaxNum 100  
33.   
34. //typedef struct  
35. //{  
36. //  int  ArrivalTime[MaxNum];  //到达时间  
37. //  int  ServiceTime[MaxNum];  //服务时间  
38. //  int  FinishTime[MaxNum];   //完成时间  
39. //  
40. //  
41. //}Process;  
42.   
43. /* 算法思想： 
44.    1. Initial()进行初始化 
45.    2. input()对到达时间和服务时间进行输入 
46.    3. get_firstProcess()获得第一个进程，FCFS和SJF算法的实现相同 
47.    4. FCFS()对算法进行处理 
48.    5. SJF()对算法进行处理 
49.    6. choose_Algorithm();对实现算法的类别进行选择：具有容错性特征 
50. */  
51.   
52. //相同的数组下标对应同一个进程的信息  
53. int  ArrivalTime[MaxNum];  //到达时间  
54. int  ServiceTime[MaxNum];  //服务时间  
55. int  FinishTime[MaxNum];   //完成时间  
56. int  WholeTime[MaxNum];    //周转时间  
57. double  WeightWholeTime[MaxNum];      //带权周转时间  
58. double AverageWT_FCFS,AverageWT_SJF;  //FCFS算法的平均周转时间，SJF算法的平均周转时间  
59. double AverageWWT_FCFS,AverageWWT_SJF; //FCFS算法的平均带权周转时间，SJF算法的平均带权周转时间  
60.   
61. bool isFinished_FCFS[MaxNum];  
62. bool isFinished_SJF[MaxNum];  
63.   
64. static int n;  
65.   
66. void Initial()  //确定进程个数后再初始化  
67. {  
68.     cout<<"请输入作业（进程）个数n=";  
69.     cin>>n;  
70.   
71.     for (int i=0;i<n;i++)  
72.     {  
73.         ArrivalTime[i] = 0;  
74.         ServiceTime[i] = 0;  
75.         FinishTime[i] = 0;  
76.         WholeTime[i] = 0;  
77.         WeightWholeTime[i] = 0;  
78.         AverageWT_FCFS = 0;  
79.         AverageWT_SJF = 0;  
80.         AverageWWT_FCFS = 0;  
81.         AverageWWT_SJF = 0;  
82.         isFinished_FCFS[i] = false;  
83.         isFinished_SJF[i] = false;  
84.     }  
85. }  
86.   
87. void input()  
88. {  
89.     cout<<"请分别输入每个进程的到达时间："<<endl;  
90.     for (int i=0;i<n;i++)  
91.     {  
92.         cin>>ArrivalTime[i];  
93.     }  
94.   
95.     cout<<"请分别输入每个进程的服务时间："<<endl;  
96.     for (int i=0;i<n;i++)  
97.     {  
98.         cin>>ServiceTime[i];  
99.     }  
100.   
101.     //输出用户输入的信息  
102.     cout<<"******************************************************"<<endl;  
103.     cout<<"用户输入的进程个数n="<<n<<endl;  
104.   
105.     cout<<"用户输入的服务时间分别为："<<endl;  
106.     for (int i=0;i<n;i++)  
107.     {  
108.         cout<<ArrivalTime[i]<<" ";  
109.     }  
110.     cout<<endl;  
111.   
112.     cout<<"用户输入的服务时间分别为："<<endl;  
113.     for (int i=0;i<n;i++)  
114.     {  
115.         cout<<ServiceTime[i]<<" ";  
116.     }  
117.     cout<<endl<<"******************************************************"<<endl;  
118. }  
119.   
120. int get_firstProcess()  
121. {  
122.     int first = MaxNum;  
123.     for (int i=0;i<n;i++)  
124.     {  
125.         if (ArrivalTime[i]<=ArrivalTime[first])  
126.         {  
127.             first = i;  
128.         }  
129.     }  
130.     return first;  
131. }  
132.   
133. void display()  
134. {  
135.     cout<<"******************************************************"<<endl;  
136.     cout<<"进程相关信息如下："<<endl;  
137.     cout<<setw(10)<<"进程名（ID）"<<" ";  
138.     cout<<setw(10)<<"到达时间"<<" ";  
139.     cout<<setw(10)<<"服务时间"<<" ";  
140.     cout<<setw(10)<<"完成时间"<<" ";  
141.     cout<<setw(10)<<"周转时间"<<" ";  
142.     cout<<setw(10)<<"带权周转时间"<<endl;  
143.     for (int i = 0;i<n;i++)  
144.     {  
145.         cout<<setw(10)<<i+1<<" ";  
146.         cout<<setw(10)<<ArrivalTime[i]<<" ";  
147.         cout<<setw(10)<<ServiceTime[i]<<" ";  
148.         cout<<setw(10)<<FinishTime[i]<<" ";  
149.         cout<<setw(10)<<WholeTime[i]<<" ";  
150.         cout<<setw(10)<<WeightWholeTime[i]<<" "<<endl;  
151.     }  
152. }  
153.   
154. void FCFS()  
155. {  
156.     /* 
157.         1. 找到最先到达的进程的坐标，并计算相关信息 
158.         2. 依次找到接下去到达的进程 
159.     */  
160.   
161.     int startWorkTime = 0;  //表示开始执行时间 = 当前进程之前的所有服务时间之和  
162.     int first = get_firstProcess();  //获得第一个进程  
163.   
164.     isFinished_FCFS[first] = true;  
165.     FinishTime[first] = ArrivalTime[first] + ServiceTime[first];  
166.     startWorkTime += ServiceTime[first];   //下一个进程的开始执行时间  
167.     WholeTime[first] = FinishTime[first] - ArrivalTime[first];   //周转时间 = 完成时间 - 到达时间  
168.     WeightWholeTime[first] = WholeTime[first]/ServiceTime[first]; //带权周转时间 = 周转时间/服务时间  
169.   
170.     //接下去的进程  
171.     int nextProcess = n; //初始化下一个进程的下标超出界限  
172.   
173.     for (int i=1;i<n;i++)  
174.     {  
175.         nextProcess = n;  //每次对下一个进程的下标进行更新  
176.         for (int j=0;j<n;j++)  
177.         {  
178.             if (!isFinished_FCFS[j])  //表示当前进程还未完成相关信息的计算  
179.             {  
180.                 if (ArrivalTime[j]<=startWorkTime)  //满足到达时间小于等于开始执行时间的情况下  
181.                 {  
182.                     if (nextProcess==n)  
183.                     {  
184.                         nextProcess = j;  
185.                     }  
186.                     else  
187.                     {  
188.                         if (ArrivalTime[nextProcess]>ArrivalTime[j])  //筛选出最先到达的进程  
189.                         {  
190.                             nextProcess=j;    //获得当前进程中：最先到达的进程  
191.                         }  
192.                     }  
193.                 }  
194.             }  
195.         }//for(j)  
196.         //获得当前需要处理的进程nextProcess后，对相关信息进行计算  
197.         isFinished_FCFS[nextProcess] = true;  
198.         FinishTime[nextProcess] = ServiceTime[nextProcess] + startWorkTime;  
199.         startWorkTime += ServiceTime[nextProcess];  //获得下一个进程对应的“开始执行时间”  
200.         WholeTime[nextProcess] = FinishTime[nextProcess] - ArrivalTime[nextProcess];  
201.         WeightWholeTime[nextProcess] = (double)WholeTime[nextProcess]/ServiceTime[nextProcess];  
202.   
203.     }//for(i)  
204.   
205.     //计算平均周转时间和平均带权周转时间  
206.     double totalWT = 0;  
207.     double totalWWT = 0;  
208.     for (int i=0;i<n;i++)  
209.     {  
210.         totalWT+=WholeTime[i];  
211.         totalWWT+=WeightWholeTime[i];  
212.     }  
213.     AverageWT_FCFS = totalWT/n;  
214.     AverageWWT_FCFS = totalWWT/n;  
215.   
216.     //输出检测  
217.     display();  
218.     cout<<"平均周转时间="<<AverageWT_FCFS<<endl;  
219.     cout<<"平均带权周转时间="<<AverageWWT_FCFS<<endl;  
220.     cout<<"******************************************************"<<endl;  
221. }  
222.   
223. void SJF()  
224. {  
225.     //与SCSF类似，相同的方法获得第一个进程  
226.     int startWorkTime_SJF = 0;  //表示开始执行时间 = 当前进程之前的所有服务时间之和  
227.     //第一个进程的处理  
228.     int first = get_firstProcess();  //获得第一个进程  
229.   
230.     isFinished_SJF[first] = true;  
231.     FinishTime[first] = ArrivalTime[first] + ServiceTime[first];  
232.     startWorkTime_SJF += ServiceTime[first];   //下一个进程的开始执行时间  
233.     WholeTime[first] = FinishTime[first] - ArrivalTime[first];   //周转时间 = 完成时间 - 到达时间  
234.     WeightWholeTime[first] = (double)WholeTime[first]/ServiceTime[first]; //带权周转时间 = 周转时间/服务时间  
235.   
236.     //获得下一个进程的下标  
237.       
238.     int nextProcess_SJF = n;  
239.     for (int i=1;i<n;i++)  
240.     {  
241.         nextProcess_SJF = n;  
242.         for (int j=0;j<n;j++)  
243.         {  
244.             if (!isFinished_SJF[j])  
245.             {  
246.                 if (ArrivalTime[j]<=startWorkTime_SJF)  
247.                 {  
248.                     if (nextProcess_SJF==n)  
249.                     {  
250.                         nextProcess_SJF = j;  
251.                     }  
252.                     else  
253.                     {  
254.                         if (ServiceTime[nextProcess_SJF]>ServiceTime[j])  
255.                         {  
256.                             nextProcess_SJF = j;   //获得运行时间最短的作业的下标  
257.                         }  
258.                     }  
259.                 }  
260.             }  
261.         }//for(j)  
262.           
263.         //对获得的进程进行处理  
264.         isFinished_SJF[nextProcess_SJF] = true;  
265.         FinishTime[nextProcess_SJF] = ServiceTime[nextProcess_SJF] + startWorkTime_SJF;  
266.         startWorkTime_SJF += ServiceTime[nextProcess_SJF];   
267.         WholeTime[nextProcess_SJF] = FinishTime[nextProcess_SJF] - ArrivalTime[nextProcess_SJF];  
268.         WeightWholeTime[nextProcess_SJF] = (double)WholeTime[nextProcess_SJF]/ServiceTime[nextProcess_SJF];  
269.   
270.     }//for(i)  
271.   
272.     double totalWT = 0;  
273.     double totalWWT = 0;  
274.     for (int i=0;i<n;i++)  
275.     {  
276.         totalWT+=WholeTime[i];  
277.         totalWWT+=WeightWholeTime[i];  
278.     }  
279.     AverageWT_SJF = totalWT/n;  
280.     AverageWWT_SJF = totalWWT/n;  
281.   
282.     //输出检测  
283.     display();  
284.     cout<<"平均周转时间="<<AverageWT_SJF<<endl;  
285.     cout<<"平均带权周转时间="<<AverageWWT_SJF<<endl;  
286.     cout<<"******************************************************"<<endl;  
287. }  
288.   
289. void choose_Algorithm()  
290. {  
291.     cout<<"请选择算法“1-FCFS，2-SJF”"<<endl;  
292.     int choose;  
293.     cin>>choose;  
294.     if (choose==1)  
295.     {  
296.         FCFS();  
297.     }  
298.         else if(choose==2)  
299.         {  
300.             SJF();  
301.         }  
302.     else  
303.     {  
304.         cout<<"请输入正确的选择“1-FCFS，2-SJF”"<<endl;  
305.         cout<<"******************************************************"<<endl;  
306.         choose_Algorithm();  //递归调用，实现排除错误的选择也可以继续输入  
307.     }  
308. }  
309.   
310.   
311.   
312. int main()  
313. {  
314.     Initial();  
315.     input();  
316.     choose_Algorithm();  
317.     system("pause");  
318.     return 0;  
319. }