FCFS 调度算法(first come first service)
l 用于作业调度： 每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。
l 用于进程调度： 每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。
l FCFS算法比较有利于长作业(进程)，而不利于短作业(进程)
有利于CPU繁忙型的作业，而不利于I/O繁忙型的作业(进程)。
[CPU繁忙型作业是指该类作业需要大量的CPU时间进行计算，而很少请求I/O。通常的科学计算便属于CPU繁忙型作业。
I/O繁忙型作业是指CPU进行处理时需频繁地请求I/O。目前的大多数事务处理都属于I/O繁忙型作业。]
SJF 短作业进程（Shortest Job First）
l 用于作业调度：
作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行
l 用于进程调度：
从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度
FCFS:
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:
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. }
1. Initial()进行初始化。
2. input()对到达时间和服务时间进行输入。
3. get_firstProcess()获得第一个进程，FCFS和SJF算法的实现相同。
4. FCFS()对算法进行处理。
5. SJF()对算法进行处理。
6. choose_Algorithm();对实现算法的类别进行选择：具有容错性特征。