• 操作系统进程调度算法的模拟实现（c语言版本）

            前言：本文旨在分享如何使用c语言对操作系统中的部分进程调度算法进行模拟实现，以及算法描述的讲解，完整代码放在文章末尾，欢迎大家自行拷贝调用

    目录

    常见的调度算法

    数据结构

    先来先服务调度算法

    算法模拟思路：

    算法模拟： 

    最短作业优先调度算法

    算法模拟思路：

    算法模拟：

     最高优先级调度算法

    算法模拟思路：

    算法模拟：

     时间片轮转调度算法

    算法模拟思路：

    算法模拟： 

    完整代码：

     course.h： 

    course.cpp：

    test.cpp： 

    常见的调度算法

    • 先来先服务调度算法
    • 最短作业优先调度算法
    • 高响应比优先调度算法
    • 最高优先级调度算法
    • 时间片轮转调度算法
    • 多级反馈队列调度算法
    • ... ...

    数据结构

    1. typedef struct program
    2. {
    3. 	char name[20];
    4. 	int running_time;
    5. 	int enter_time;
    6. 	int priority;
    7. 	int done_time;			//用于时间片轮转
    8. 	int copyRunning_time;   //用于时间片轮转
    9. 	int start_time;
    10. 	program* next;
    11. } Program;
    12.  
    13. typedef struct programQueue
    14. {
    15. 	program* firstProg;
    16. 	program* LastProg;
    17. 	int size;
    18. } programQueue;

    先来先服务调度算法

            顾名思义，先来后到，每次从就绪队列选择最先进入队列的进程，然后一直运行，直到进程退出或被阻塞，才会继续从队列中选择第一个进程接着运行。但是当一个长作业先运行了，那么后面的短作业等待的时间就会很长，不利于短作业。FCFS 对长作业有利，适用于 CPU 繁忙型作业的系统，而不适用于 I/O 繁忙型作业的系统。

    算法模拟思路：

    1. 首先将输入的进程放入一个进程数组中，然后根据进程的到达时间进行排序，将最先到达的进程放入进程就绪队列中。
    2. 当队列不空时，从队头取出一个进程来执行，直至此进程执行完，并将在此进程执行期间到达的进程依次加入进程就绪队列。
    3. 如果队列为空，但进程数组中仍存在未到达的进程，这时将要到达进程加入进程就绪队列。

    算法模拟： 

    1. //FCFS先来先服务算法
    2. void FCFS(program pro[], int num)
    3. {
    4. 	printf("进程 到达时间  服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
    5. 	sortWithEnterTime(pro, num);    //按照进入顺序排序 
    6. 	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));
    7. 	Queueinit(queue);
    8. 	EnterQueue(queue, &pro[0]);
    9. 	int time = pro[0].enter_time;
    10. 	int pronum = 1;    //记录当前的进程 
    11. 	float sum_T_time = 0, sum_QT_time = 0;
    12. 	while (queue->size > 0)
    13. 	{
    14. 		program* curpro = poll(queue);   //从进程队列中取出进程 
    15. 		if (time < curpro->enter_time)
    16. 			time = curpro->enter_time;
    17. 		int done_time = time + curpro->running_time;
    18. 		int T_time = done_time - curpro->enter_time;
    19. 		sum_T_time += T_time;
    20. 		float QT_time = T_time / (curpro->running_time + 0.0);
    21. 		sum_QT_time += QT_time;
    22. 		for (int tt = time; tt <= done_time && pronum < num; tt++)
    23. 		{
    24. 			//模拟进程的执行过程 
    25. 			if (tt >= pro[pronum].enter_time)
    26. 			{
    27. 				EnterQueue(queue, &pro[pronum]);
    28. 				pronum++;
    29. 			}
    30. 		}
    31. 		printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n", curpro->name, curpro->enter_time, curpro->running_time, time, done_time, T_time, QT_time);
    32. 		time += curpro->running_time;
    33. 		if (queue->size == 0 && pronum < num)
    34. 		{
    35. 			//防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    36. 			EnterQueue(queue, &pro[pronum]);
    37. 			pronum++;
    38. 		}
    39. 	}
    40. 	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n", sum_T_time / (num + 0.0), sum_QT_time / (num + 0.0));
    41. }

    最短作业优先调度算法

            最短作业优先调度算法会优先选择运行时间最短的进程来运行，这有助于提高系统的吞吐量。这显然对长作业不利，很容易造成一种极端现象。比如，一个长作业在就绪队列等待运行，而这个就绪队列有非常多的短作业，那么就会使得长作业不断的往后推，周转时间变长，致使长作业长期不会被运行。

    算法模拟思路：

    1. 首先也是按进程的到达时间进行排序。让最先到达的进程入队。
    2. 当队列不空时，从队头取出一个进程来执行，直至此进程执行完，设置一个变量记录此进程执行过程中所有到达的进程。
    3. 将这些到达的进程进行排序，按照进程服务时间的大小。然后将排序好的进程数组中的进程依次加入进程队列。（只排当前进程执行期间到达的进程）
    4. 此时也要考虑如果队列为空，但进程数组中仍存在未到达的进程，这时将要到达进程加入进程就绪队列。

    算法模拟：

    1. //短作业优先算法
    2. void SJF(program pro[], int num)
    3. {
    4. 	printf("进程 到达时间  服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
    5. 	sortWithEnterTime(pro, num);
    6. 	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));
    7. 	Queueinit(queue);
    8. 	EnterQueue(queue, &pro[0]);
    9. 	int time = pro[0].enter_time;
    10. 	int pronum = 1;    //记录当前的进程 
    11. 	float sum_T_time = 0, sum_QT_time = 0;
    12. 	while (queue->size > 0)
    13. 	{
    14. 		program* curpro = poll(queue);   //从进程队列中取出进程 
    15. 		if (time < curpro->enter_time)
    16. 			time = curpro->enter_time;
    17. 		int done_time = time + curpro->running_time;
    18. 		int T_time = done_time - curpro->enter_time;
    19. 		float QT_time = T_time / (curpro->running_time + 0.0);
    20. 		sum_T_time += T_time;
    21. 		sum_QT_time += QT_time;
    22. 		int pre = pronum;
    23. 		for (int tt = time; tt <= done_time && pronum < num; tt++)
    24. 		{
    25. 			//模拟进程的执行过程 
    26. 			if (tt >= pro[pronum].enter_time)
    27. 			{
    28. 				// 统计从此任务开始到结束之间有几个进程到达 
    29. 				pronum++;
    30. 			}
    31. 		}
    32. 		sortWithLongth(pro, pre, pronum);//将到达的进程按照服务时间排序
    33. 		for (int i = pre; i < pronum; i++)
    34. 		{
    35. 			//将进程链入队列 
    36. 			EnterQueue(queue, &pro[i]);
    37. 		}
    38. 		pre = pronum;
    39. 		printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n", curpro->name, curpro->enter_time, curpro->running_time, time, done_time, T_time, QT_time);
    40. 		time += curpro->running_time;
    41. 		if (queue->size == 0 && pronum < num)
    42. 		{
    43. 			//防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    44. 			EnterQueue(queue, &pro[pronum]);
    45. 			pronum++;
    46. 		}
    47. 	}
    48. 	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n", sum_T_time / (num + 0.0), sum_QT_time / num);
    49. }

     最高优先级调度算法

    进程的优先级可以分为，静态优先级或动态优先级：

    • 静态优先级：创建进程时候，就已经确定了优先级了，然后整个运行时间优先级都不会变化；
    • 动态优先级：根据进程的动态变化调整优先级，比如如果进程运行时间增加，则降低其优先级，如果进程等待时间（就绪队列的等待时间）增加，则升高其优先级，也就是随着时间的推移增加等待进程的优先级。

    该算法也有两种处理优先级高的方法，非抢占式和抢占式：

    • 非抢占式：当就绪队列中出现优先级高的进程，运行完当前进程，再选择优先级高的进程。
    • 抢占式：当就绪队列中出现优先级高的进程，当前进程挂起，调度优先级高的进程运行。

    但是依然有缺点，可能会导致低优先级的进程永远不会运行

    算法模拟思路：

    1. 首先也是按进程的到达时间进行排序。让最先到达的进程入队。
    2. 当队列不空时，从队头取出一个进程来执行，直至此进程执行完，设置一个变量记录此进程执行过程中所有到达的进程。
    3. 将这些到达的进程进行排序，按照进程优先权排序（权值小的先入）。然后将排序好的进程数组中的进程依次加入进程队列。（只排当前进程执行期间到达的进程）
    4. 此时也要考虑如果队列为空，但进程数组中仍存在未到达的进程，这时将要到达进程加入进程就绪队列。

    算法模拟：

    1. //优先权高者优先（HPF）
    2. void HPF(program pro[], int num)
    3. {
    4. 	printf("进程 到达时间  服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
    5. 	sortWithEnterTime(pro, num);
    6. 	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));
    7. 	Queueinit(queue);
    8. 	EnterQueue(queue, &pro[0]);
    9. 	int time = pro[0].enter_time;
    10. 	int pronum = 1;    //记录当前的进程 
    11. 	float sum_T_time = 0, sum_QT_time = 0;
    12. 	while (queue->size > 0)
    13. 	{
    14. 		program* curpro = poll(queue);   //从进程队列中取出进程 
    15. 		if (time < curpro->enter_time)
    16. 			time = curpro->enter_time;
    17. 		int done_time = time + curpro->running_time;
    18. 		int T_time = done_time - curpro->enter_time;
    19. 		float QT_time = T_time / (curpro->running_time + 0.0);
    20. 		sum_T_time += T_time;
    21. 		sum_QT_time += QT_time;
    22. 		int pre = pronum;
    23. 		for (int tt = time; tt <= done_time && pronum < num; tt++)
    24. 		{
    25. 			//模拟进程的执行过程 
    26. 			if (tt >= pro[pronum].enter_time)
    27. 			{
    28. 				// 统计从此任务开始到结束之间有几个进程到达 
    29. 				pronum++;
    30. 			}
    31. 		}
    32. 		sortWithPriority(pro, pre, pronum);//将到达的进程按照服务时间排序
    33. 		for (int i = pre; i < pronum; i++)
    34. 		{
    35. 			//将进程链入队列 
    36. 			EnterQueue(queue, &pro[i]);
    37. 		}
    38. 		pre = pronum;
    39. 		printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n", curpro->name, curpro->enter_time, curpro->running_time, time, done_time, T_time, QT_time);
    40. 		time += curpro->running_time;
    41. 		if (queue->size == 0 && pronum < num)
    42. 		{
    43. 			//防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    44. 			EnterQueue(queue, &pro[pronum]);
    45. 			pronum++;
    46. 		}
    47. 	}
    48. 	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n", sum_T_time / (num + 0.0), sum_QT_time / (num + 0.0));
    49. }

     时间片轮转调度算法

            每个进程被分配一个时间段，称为时间片，即允许该进程在该时间段中运行。如果时间片用完，进程还在运行，那么将会把此进程从 CPU 释放出来，并把 CPU 分配另外一个进程；如果该进程在时间片结束前阻塞或结束，则 CPU 立即进行切换；如果时间片设得太短会导致过多的进程上下文切换，降低了 CPU 效率；如果设得太长又可能引起对短作业进程的响应时间变长。

    算法模拟思路：

    1. 首先也是按进程的到达时间进行排序。让最先到达的进程入队。
    2. 当队列不空时，从队头取出一个进程来执行。此时分两种情况：①如果当前进程的剩余服务时间不大于时间片大小，说明此次将会将这个进程执 行完毕，在此进程执行过程中到达的进程需要添加到进程就绪队列中，这时就可以输出 此进程执行完毕②如果当前进程的剩余服务时间大于时间片大小，还需将此进程执行过程中到达 的进程需要添加到进程就绪队列中，然后此进程的剩余服务时间减少时间片大小，此进 程重新进入进程就绪队列
    3. 此时也要考虑如果队列为空，但进程数组中仍存在未到达的进程，这时将要到达进程加入进程就绪队列

    算法模拟： 

    1. //时间片轮转（RR）
    2. void RR(program pro[], int num)
    3. {
    4. 	printf("请输入时间片大小");
    5. 	int timeslice; scanf("%d", ×lice);
    6. 	printf("进程 到达时间  服务时间 进入时间 完成时间 周转时间 带权周转时间\n");
    7. 	sortWithEnterTime(pro, num);
    8. 	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));
    9. 	Queueinit(queue);
    10. 	pro[0].start_time = pro[0].enter_time;
    11. 	EnterQueue(queue, &pro[0]);
    12. 	int time = 0;
    13. 	int pronum = 1;
    14. 	float sum_T_time = 0, sum_QT_time = 0;
    15. 	while (queue->size > 0)
    16. 	{
    17. 		program* curpro = poll(queue);    // 从队列中取出头节点 
    18. 		if (time < curpro->enter_time)
    19. 			time = curpro->enter_time;
    20. 		if (timeslice >= curpro->running_time)
    21. 		{
    22. 			// 如果剩余时间小于时间片  则此任务完成
    23. 			for (int tt = time; tt <= time + curpro->running_time && pronum < num; tt++)
    24. 			{
    25. 				// 模拟进程的执行过程 
    26. 				if (tt >= pro[pronum].enter_time)
    27. 				{
    28. 					// 统计从此任务开始到结束之间有几个进程到达 
    29. 					pro[pronum].start_time = tt;
    30. 					EnterQueue(queue, &pro[pronum]);
    31. 					pronum++;
    32. 				}
    33. 			}
    34. 			time += curpro->running_time;
    35. 			curpro->running_time = 0;
    36. 			curpro->done_time = time;
    37. 			int T_time = curpro->done_time - curpro->start_time;
    38. 			float QT_time = T_time / (curpro->copyRunning_time + 0.0);
    39. 			sum_T_time += T_time;
    40. 			sum_QT_time += QT_time;
    41. 			printf("%s\t%d\t%d\t  %d\t   %d\t %d\t  %.2f\n", curpro->name, curpro->enter_time, curpro->copyRunning_time,
    42. 				curpro->start_time, curpro->done_time, T_time, QT_time);
    43. 			if (queue->size == 0 && pronum < num)
    44. 			{
    45. 				//防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    46. 				pro[pronum].start_time = pro[pronum].enter_time;
    47. 				EnterQueue(queue, &pro[pronum]);
    48. 				pronum++;
    49. 			}
    50. 			continue;
    51. 		}
    52. 		for (int tt = time; tt <= time + timeslice && pronum < num; tt++)
    53. 		{
    54. 			//模拟进程的执行过程 
    55. 			if (tt >= pro[pronum].enter_time)
    56. 			{
    57. 				// 统计从此任务开始到结束之间有几个进程到达 
    58. 				pro[pronum].start_time = tt;
    59. 				EnterQueue(queue, &pro[pronum]);
    60. 				pronum++;
    61. 			}
    62. 		}
    63. 		time += timeslice;
    64. 		curpro->running_time -= timeslice;
    65. 		EnterQueue(queue, curpro);    //当前程序未完成  继续添加到队列中 
    66. 		if (queue->size == 0 && pronum < num)
    67. 		{
    68. 			//防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    69. 			pro[pronum].start_time = pro[pronum].enter_time;
    70. 			EnterQueue(queue, &pro[pronum]);
    71. 			pronum++;
    72. 		}
    73. 	}
    74. 	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n\n", sum_T_time / (num + 0.0), sum_QT_time / (num + 0.0));
    75. }

    完整代码：

    我们分三个文件进行操作，当然大家也可以把三个文件按顺序放在一个文件里面进行操作

    course.h：      结构体的包含以及函数的声明

    course.cpp：  函数的具体实现

    test.cpp：       主函数用于调用其余文件函数

     course.h：  

    1. #pragma once
    2. #define _CRT_SECURE_NO_WARNINGS 1
    3.  
    4. #include
    5. #include
    6. #include 
    7. #include
    8.  
    9. typedef struct program
    10. {
    11. 	char name[20];
    12. 	int running_time;
    13. 	int enter_time;
    14. 	int priority;
    15. 	int done_time;			//用于时间片轮转
    16. 	int copyRunning_time;   //用于时间片轮转
    17. 	int start_time;
    18. 	program* next;
    19. } Program;
    20.  
    21. typedef struct programQueue
    22. {
    23. 	program* firstProg;
    24. 	program* LastProg;
    25. 	int size;
    26. } programQueue;
    27.  
    28. //初始化
    29. void Queueinit(programQueue* queue);
    30.  
    31. //打印
    32. void print(program pro[], int num);
    33.  
    34. //打印队列
    35. void printQueue(programQueue* queue);
    36.  
    37. //加入进程队列 
    38. void EnterQueue(programQueue* queue, program* pro);
    39.  
    40. //查询
    41. program* poll(programQueue* queue);
    42.  
    43. //输入
    44. void inputProgram(program pro[], int num);
    45.  
    46. //根据时间排序
    47. void sortWithEnterTime(program pro[], int num);
    48.  
    49. //FCFS先来先服务算法
    50. void FCFS(program pro[], int num);
    51.  
    52. //根据长度排序
    53. void sortWithLongth(program pro[], int start, int end);
    54.  
    55. //短作业优先算法
    56. void SJF(program pro[], int num);
    57.  
    58. //根据优先级排列
    59. void sortWithPriority(program pro[], int start, int end);
    60.  
    61. //优先权高者优先（HPF）
    62. void HPF(program pro[], int num);
    63.  
    64. //时间片轮转（RR）
    65. void RR(program pro[], int num);
    66.  
    67. //选择菜单
    68. void choiceMenu();

    course.cpp：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include "course.h"
    3.  
    4. //初始化
    5. void Queueinit(programQueue* queue)
    6. {
    7. 	if (queue == NULL)
    8. 	{
    9. 		return;
    10. 	}
    11. 	queue->size = 0;
    12. 	queue->LastProg = (program*)malloc(sizeof(program));
    13. 	queue->firstProg = queue->LastProg;
    14. }
    15.  
    16. //打印
    17. void print(program pro[], int num)
    18. {
    19. 	for (int i = 0; i < num; i++)
    20. 	{
    21. 		printf("%d ", pro[i].enter_time);
    22. 	}
    23. }
    24.  
    25. //打印输出队列
    26. void printQueue(programQueue* queue)
    27. {
    28. 	program* p = queue->firstProg->next;
    29. 	while (p != NULL)
    30. 	{
    31. 		printf("%s ", p->name);
    32. 		p = p->next;
    33. 	}
    34. 	printf("\n");
    35. }
    36.  
    37. //加入进程队列 
    38. void EnterQueue(programQueue* queue, program* pro)
    39. {
    40. 	queue->LastProg->next = (program*)malloc(sizeof(program));
    41. 	queue->LastProg = queue->LastProg->next;
    42. 	queue->LastProg->enter_time = pro->enter_time;
    43. 	memcpy(queue->LastProg->name, pro->name, sizeof(pro->name));
    44. 	queue->LastProg->priority = pro->priority;
    45. 	queue->LastProg->running_time = pro->running_time;
    46. 	queue->LastProg->copyRunning_time = pro->copyRunning_time;
    47. 	queue->LastProg->start_time = pro->start_time;
    48. 	queue->size++;
    49. }
    50.  
    51. //查询
    52. program* poll(programQueue* queue)
    53. {
    54. 	program* temp = queue->firstProg->next;
    55. 	if (temp == queue->LastProg)
    56. 	{
    57. 		queue->LastProg = queue->firstProg;
    58. 		queue->size--;
    59. 		return temp;
    60. 	}
    61. 	queue->firstProg->next = queue->firstProg->next->next;
    62. 	queue->size--;
    63. 	return temp;
    64. }
    65.  
    66. //输入
    67. void inputProgram(program pro[], int num)
    68. {
    69. 	for (int i = 0; i < num; i++)
    70. 	{
    71. 		program prog;
    72. 		printf("请输入第%d个进程的名字，到达时间，服务时间，优先级\n", i + 1);
    73. 		scanf("%s", prog.name);
    74. 		scanf("%d", &prog.enter_time);
    75. 		scanf("%d", &prog.running_time);
    76. 		prog.copyRunning_time = prog.running_time;
    77. 		scanf("%d", &prog.priority);
    78. 		pro[i] = prog;
    79. 	}
    80. }
    81.  
    82. //根据时间排序
    83. void sortWithEnterTime(program pro[], int num)
    84. {
    85. 	for (int i = 1; i < num; i++)
    86. 	{
    87. 		for (int j = 0; j < num - i; j++)
    88. 		{
    89. 			if (pro[j].enter_time > pro[j + 1].enter_time)
    90. 			{
    91. 				program temp = pro[j];
    92. 				pro[j] = pro[j + 1];
    93. 				pro[j + 1] = temp;
    94. 			}
    95. 		}
    96. 	}
    97. }
    98.  
    99. //FCFS先来先服务算法
    100. void FCFS(program pro[], int num)
    101. {
    102. 	printf("进程 到达时间  服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
    103. 	sortWithEnterTime(pro, num);    //按照进入顺序排序 
    104. 	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));
    105. 	Queueinit(queue);
    106. 	EnterQueue(queue, &pro[0]);
    107. 	int time = pro[0].enter_time;
    108. 	int pronum = 1;    //记录当前的进程 
    109. 	float sum_T_time = 0, sum_QT_time = 0;
    110. 	while (queue->size > 0)
    111. 	{
    112. 		program* curpro = poll(queue);   //从进程队列中取出进程 
    113. 		if (time < curpro->enter_time)
    114. 			time = curpro->enter_time;
    115. 		int done_time = time + curpro->running_time;
    116. 		int T_time = done_time - curpro->enter_time;
    117. 		sum_T_time += T_time;
    118. 		float QT_time = T_time / (curpro->running_time + 0.0);
    119. 		sum_QT_time += QT_time;
    120. 		for (int tt = time; tt <= done_time && pronum < num; tt++)
    121. 		{
    122. 			//模拟进程的执行过程 
    123. 			if (tt >= pro[pronum].enter_time)
    124. 			{
    125. 				EnterQueue(queue, &pro[pronum]);
    126. 				pronum++;
    127. 			}
    128. 		}
    129. 		printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n", curpro->name, curpro->enter_time, curpro->running_time, time, done_time, T_time, QT_time);
    130. 		time += curpro->running_time;
    131. 		if (queue->size == 0 && pronum < num)
    132. 		{
    133. 			//防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    134. 			EnterQueue(queue, &pro[pronum]);
    135. 			pronum++;
    136. 		}
    137. 	}
    138. 	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n", sum_T_time / (num + 0.0), sum_QT_time / (num + 0.0));
    139. }
    140.  
    141. //根据长度排序
    142. void sortWithLongth(program pro[], int start, int end)
    143. {
    144. 	int len = end - start;
    145. 	if (len == 1) return;
    146. 	for (int i = 1; i < len; i++) {
    147. 		for (int j = start; j < end - i; j++)
    148. 		{
    149. 			if (pro[j].running_time > pro[j + 1].running_time)
    150. 			{
    151. 				program temp = pro[j];
    152. 				pro[j] = pro[j + 1];
    153. 				pro[j + 1] = temp;
    154. 			}
    155. 		}
    156. 	}
    157. }
    158.  
    159. //短作业优先算法
    160. void SJF(program pro[], int num)
    161. {
    162. 	printf("进程 到达时间  服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
    163. 	sortWithEnterTime(pro, num);
    164. 	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));
    165. 	Queueinit(queue);
    166. 	EnterQueue(queue, &pro[0]);
    167. 	int time = pro[0].enter_time;
    168. 	int pronum = 1;    //记录当前的进程 
    169. 	float sum_T_time = 0, sum_QT_time = 0;
    170. 	while (queue->size > 0)
    171. 	{
    172. 		program* curpro = poll(queue);   //从进程队列中取出进程 
    173. 		if (time < curpro->enter_time)
    174. 			time = curpro->enter_time;
    175. 		int done_time = time + curpro->running_time;
    176. 		int T_time = done_time - curpro->enter_time;
    177. 		float QT_time = T_time / (curpro->running_time + 0.0);
    178. 		sum_T_time += T_time;
    179. 		sum_QT_time += QT_time;
    180. 		int pre = pronum;
    181. 		for (int tt = time; tt <= done_time && pronum < num; tt++)
    182. 		{
    183. 			//模拟进程的执行过程 
    184. 			if (tt >= pro[pronum].enter_time)
    185. 			{
    186. 				// 统计从此任务开始到结束之间有几个进程到达 
    187. 				pronum++;
    188. 			}
    189. 		}
    190. 		sortWithLongth(pro, pre, pronum);//将到达的进程按照服务时间排序
    191. 		for (int i = pre; i < pronum; i++)
    192. 		{
    193. 			//将进程链入队列 
    194. 			EnterQueue(queue, &pro[i]);
    195. 		}
    196. 		pre = pronum;
    197. 		printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n", curpro->name, curpro->enter_time, curpro->running_time, time, done_time, T_time, QT_time);
    198. 		time += curpro->running_time;
    199. 		if (queue->size == 0 && pronum < num)
    200. 		{
    201. 			//防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    202. 			EnterQueue(queue, &pro[pronum]);
    203. 			pronum++;
    204. 		}
    205. 	}
    206. 	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n", sum_T_time / (num + 0.0), sum_QT_time / num);
    207. }
    208.  
    209. //根据优先级排列
    210. void sortWithPriority(program pro[], int start, int end)
    211. {
    212. 	int len = end - start;
    213. 	if (len == 1) return;
    214. 	for (int i = 1; i < len; i++)
    215. 	{
    216. 		for (int j = start; j < end - i; j++)
    217. 		{
    218. 			if (pro[j].priority > pro[j + 1].priority)
    219. 			{
    220. 				program temp = pro[j];
    221. 				pro[j] = pro[j + 1];
    222. 				pro[j + 1] = temp;
    223. 			}
    224. 		}
    225. 	}
    226. }
    227.  
    228.  
    229. //优先权高者优先（HPF）
    230. void HPF(program pro[], int num)
    231. {
    232. 	printf("进程 到达时间  服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
    233. 	sortWithEnterTime(pro, num);
    234. 	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));
    235. 	Queueinit(queue);
    236. 	EnterQueue(queue, &pro[0]);
    237. 	int time = pro[0].enter_time;
    238. 	int pronum = 1;    //记录当前的进程 
    239. 	float sum_T_time = 0, sum_QT_time = 0;
    240. 	while (queue->size > 0)
    241. 	{
    242. 		program* curpro = poll(queue);   //从进程队列中取出进程 
    243. 		if (time < curpro->enter_time)
    244. 			time = curpro->enter_time;
    245. 		int done_time = time + curpro->running_time;
    246. 		int T_time = done_time - curpro->enter_time;
    247. 		float QT_time = T_time / (curpro->running_time + 0.0);
    248. 		sum_T_time += T_time;
    249. 		sum_QT_time += QT_time;
    250. 		int pre = pronum;
    251. 		for (int tt = time; tt <= done_time && pronum < num; tt++)
    252. 		{
    253. 			//模拟进程的执行过程 
    254. 			if (tt >= pro[pronum].enter_time)
    255. 			{
    256. 				// 统计从此任务开始到结束之间有几个进程到达 
    257. 				pronum++;
    258. 			}
    259. 		}
    260. 		sortWithPriority(pro, pre, pronum);//将到达的进程按照服务时间排序
    261. 		for (int i = pre; i < pronum; i++)
    262. 		{
    263. 			//将进程链入队列 
    264. 			EnterQueue(queue, &pro[i]);
    265. 		}
    266. 		pre = pronum;
    267. 		printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n", curpro->name, curpro->enter_time, curpro->running_time, time, done_time, T_time, QT_time);
    268. 		time += curpro->running_time;
    269. 		if (queue->size == 0 && pronum < num)
    270. 		{
    271. 			//防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    272. 			EnterQueue(queue, &pro[pronum]);
    273. 			pronum++;
    274. 		}
    275. 	}
    276. 	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n", sum_T_time / (num + 0.0), sum_QT_time / (num + 0.0));
    277. }
    278.  
    279.  
    280.  
    281. //时间片轮转（RR）
    282. void RR(program pro[], int num)
    283. {
    284. 	printf("请输入时间片大小");
    285. 	int timeslice; scanf("%d", ×lice);
    286. 	printf("进程 到达时间  服务时间 进入时间 完成时间 周转时间 带权周转时间\n");
    287. 	sortWithEnterTime(pro, num);
    288. 	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));
    289. 	Queueinit(queue);
    290. 	pro[0].start_time = pro[0].enter_time;
    291. 	EnterQueue(queue, &pro[0]);
    292. 	int time = 0;
    293. 	int pronum = 1;
    294. 	float sum_T_time = 0, sum_QT_time = 0;
    295. 	while (queue->size > 0)
    296. 	{
    297. 		program* curpro = poll(queue);    // 从队列中取出头节点 
    298. 		if (time < curpro->enter_time)
    299. 			time = curpro->enter_time;
    300. 		if (timeslice >= curpro->running_time)
    301. 		{
    302. 			// 如果剩余时间小于时间片  则此任务完成
    303. 			for (int tt = time; tt <= time + curpro->running_time && pronum < num; tt++)
    304. 			{
    305. 				// 模拟进程的执行过程 
    306. 				if (tt >= pro[pronum].enter_time)
    307. 				{
    308. 					// 统计从此任务开始到结束之间有几个进程到达 
    309. 					pro[pronum].start_time = tt;
    310. 					EnterQueue(queue, &pro[pronum]);
    311. 					pronum++;
    312. 				}
    313. 			}
    314. 			time += curpro->running_time;
    315. 			curpro->running_time = 0;
    316. 			curpro->done_time = time;
    317. 			int T_time = curpro->done_time - curpro->start_time;
    318. 			float QT_time = T_time / (curpro->copyRunning_time + 0.0);
    319. 			sum_T_time += T_time;
    320. 			sum_QT_time += QT_time;
    321. 			printf("%s\t%d\t%d\t  %d\t   %d\t %d\t  %.2f\n", curpro->name, curpro->enter_time, curpro->copyRunning_time,
    322. 				curpro->start_time, curpro->done_time, T_time, QT_time);
    323. 			if (queue->size == 0 && pronum < num)
    324. 			{
    325. 				//防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    326. 				pro[pronum].start_time = pro[pronum].enter_time;
    327. 				EnterQueue(queue, &pro[pronum]);
    328. 				pronum++;
    329. 			}
    330. 			continue;
    331. 		}
    332. 		for (int tt = time; tt <= time + timeslice && pronum < num; tt++)
    333. 		{
    334. 			//模拟进程的执行过程 
    335. 			if (tt >= pro[pronum].enter_time)
    336. 			{
    337. 				// 统计从此任务开始到结束之间有几个进程到达 
    338. 				pro[pronum].start_time = tt;
    339. 				EnterQueue(queue, &pro[pronum]);
    340. 				pronum++;
    341. 			}
    342. 		}
    343. 		time += timeslice;
    344. 		curpro->running_time -= timeslice;
    345. 		EnterQueue(queue, curpro);    //当前程序未完成  继续添加到队列中 
    346. 		if (queue->size == 0 && pronum < num)
    347. 		{
    348. 			//防止出现前一个进程执行完到下一个进程到达之间无进程进入 
    349. 			pro[pronum].start_time = pro[pronum].enter_time;
    350. 			EnterQueue(queue, &pro[pronum]);
    351. 			pronum++;
    352. 		}
    353. 	}
    354. 	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n\n", sum_T_time / (num + 0.0), sum_QT_time / (num + 0.0));
    355. }
    356.  
    357. //选择菜单
    358. void choiceMenu()
    359. {
    360. 	printf("请选择进程调度算法：\n");
    361. 	printf("1.先来先服务算法\n");
    362. 	printf("2.短进程优先算法\n");
    363. 	printf("3.高优先级优先\n");
    364. 	printf("4.时间片轮转算法\n");
    365. }

    test.cpp： 

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include"course.h"
    3.  
    4. int main()
    5. {
    6. 	int proNum = 5;		//5个进程
    7. 	program pro[5];
    8. 	inputProgram(pro, proNum);
    9. 	choiceMenu();
    10. 	int choice;
    11. 	do
    12. 	{
    13. 		scanf("%d", &choice);
    14. 		switch (choice)
    15. 		{
    16. 		case 1:
    17. 			system("cls");
    18. 			FCFS(pro, proNum);
    19. 			choiceMenu();
    20. 			break;
    21. 		case 2:
    22. 			system("cls");
    23. 			SJF(pro, proNum);
    24. 			choiceMenu();
    25. 			break;
    26. 		case 3:
    27. 			system("cls");
    28. 			HPF(pro, proNum);
    29. 			choiceMenu();
    30. 			break;
    31. 		case 4:
    32. 			system("cls");
    33. 			RR(pro, proNum);
    34. 			choiceMenu();
    35. 			break;
    36. 		default:
    37. 			printf("输入错误，请重新尝试\n");
    38. 			break;
    39. 		}
    40. 	} while (choice);
    41.  
    42. 	return 0;
    43. }

    本次的分享就到此为止了，感谢您的支持，如果您有不同意见，欢迎评论区积极交流

  • 相关阅读:
    Hugging Face发布重量级版本：Transformer 4.42
    Me-and-My-Girlfriend-1
    Linux运维技能图谱
    EasyNLP玩转文本摘要（新闻标题）生成
    【马士兵】 Python基础--11
    超越所有人的成就，牛顿的光芒也无法掩盖的天才数学巨人
    【leetcode面试经典150题】71. 对称二叉树（C++）
    工作效率-十五分钟让你快速学习Markdown语法到精通排版实践备忘
    leetcode日记（32）字符串相乘
    YOLOv5的Tricks | 【Trick14】YOLOv5的val.py脚本的解析
  • 原文地址：https://blog.csdn.net/m0_69519887/article/details/134053438