目录

1.实验目的 

2.实验内容 

3.实验要求 

4.实验环境

5.实验设计与实现

5.1实验设计

5.1.1 FSFS先来先服务算法设计

作业控制管理块设计

FSFS算法设计：根据到达时间对作业排序

5.1.2 SJF短进程优先算法设计

5.2实验实现

5.2.1 FSFS先来先服务

5.2.2 SJF短进程优先

5.2.3 PS高优先权

5.2.4 HRRN高响应比

5.2.5 RR时间片轮转

6.1 FSFS先来先服务

6.2 SJF短进程优先

6.3 PS高优先权

6.4 HRRN高响应比

6.5 RR时间片轮转

7.源代码

7.1 FSFS先来先服务

7.2 SJF短进程优先

7.3 PS高优先权

7.4 HRRN高响应比

7.5  RR时间片轮转

1.实验目的 

分析处理器实施进程调度的前提条件，理解并掌握各类处理器调度算法的设计原理和实现机制。

2.实验内容 

分析和探索处理器实施进程调度的前提条件，理解并掌握处理器调度算法的设计原理和实现机制，随机发生和模拟进程创建及相关事件，编程实现基于特定处理器调度算法（三种以上，譬如先来先服务调度算法、短进程优先调度算法、高优先权优先调度算法、高响应比优先调度算法、时间片轮转调度算法、多级反馈队列调度算法、等等）的系统调度处理过程，并加以测试验证。

3.实验要求 

本实验课题主要功能设计要求包括：

（1）选取和设计实现三种以上的处理器调度算法； 

（2）针对特定的处理器调度算法，分析处理器实施进程调度的前提条件和要求（譬如进程创建时刻、运行时间长短、各【集中计算运行/输入输出操作】时间段长短、优先级），并随机发生和模拟处理对应的进程创建及相关事件；

（3）编程实现处理器调度机制，针对特定的处理器调度算法和随机事件序列，给出相应的调度处理过程，主要涵盖进程相关事件、处理器调度操作或处理措施以及各状态进程列表；

（4）测试验证处理器调度机制的有效性及有关处理器调度算法设计方案的正确性。

4.实验环境

5.实验设计与实现

5.1实验设计

5.1.1 FSFS先来先服务算法设计

作业控制管理块设计

1. JobName：一个字符数组，长度为50，用来存储作业名称。
2. reachtime：一个整型变量，用来存储作业到达时间。
3. CPUTime：一个整型变量，用来存储CPU使用时间。
4. waitingTime：一个整型变量，用来存储等待时间。
5. turnaroundTime：一个整型变量，用来存储周转时间。

1. FSFS算法设计：根据到达时间对作业排序

   1. JobName：一个字符数组，长度为50，用来存储作业名称。
   2. reachtime：一个整型变量，用来存储作业到达时间。
   3. CPUTime：一个整型变量，用来存储CPU使用时间。
   4. waitingTime：一个整型变量，用来存储等待时间。
   5. turnaroundTime：一个整型变量，用来存储周转时间。

   

5.1.2 SJF短进程优先算法设计

作业管理控制块设计

核心算法设计：根据每个作业使用CPU的时间排序

5.1.3 PS高优先权算法设计

作业管理控制块设计

1. JobName：一个字符数组，长度为50，用来存储作业名称。
2. reachtime：一个整型变量，用来存储作业到达时间。
3. CPUTime：一个整型变量，用来存储CPU使用时间。
4. waitingTime：一个整型变量，用来存储等待时间。
5. turnaroundTime：一个整型变量，用来存储周转时间。
6. prority：一个整型变量，用来存储作业的优先级。

核心算法设计

​​​​​​​5.1.4 HRRN高响应比算法设计

作业管理控制块设计

核心算法设计

​​​​​​​5.1.5 RR时间片轮转算法设计

1. 作业管理控制块设计

1. JobName：一个字符数组，长度为20，用来存储作业名称。
2. arrivalTime：一个整型变量，用来存储作业的到达时间。
3. serviceTime：一个整型变量，用来存储作业的服务时间，即CPU时间。
4. remainingTime：一个整型变量，用来存储作业的剩余服务时间。
5. completionTime：一个整型变量，用来存储作业的完成时间。
6. turnaroundTime：一个整型变量，用来存储作业的周转时间。
7. waitingTime：一个整型变量，用来存储作业的等待时间。
8. isCompleted：一个布尔型变量，用来表示作业是否已经完成。

1. 核心算法设计（其中时间片长度为4s）

5.2实验实现

5.2.1 FSFS先来先服务

（1）代码实现

1.自定义结构体

1. //创建JCB  
2. typedef struct{  
3.     char JobName[50];         //作业名称  
4.     int reachtime;            //作业到达时间  
5.     int CPUTime;              //CPU使用时间  
6.     int waitingTime;          //等待时间  
7.     int turnaroundTime;       //周转时间  
8. }JCBFCFS;  
9. 核心算法实现
10. void FCFS() {  
11.     int time = 0;  
12.     for (int i = 0; i < Jobcount; i++) {  
13.           
14.         if (jobqueue[i].reachtime > time) {  
15.             time = jobqueue[i].reachtime;  
16.         }  
17.         jobqueue[i].waitingTime = time - jobqueue[i].reachtime;  
18.         jobqueue[i].turnaroundTime = jobqueue[i].waitingTime + jobqueue[i].CPUTime;  
19.         // 模拟作业执行  
20.         printf("正在执行作业: %s，所需时间: %d，当前时间: %d\n",  
21.             jobqueue[i].JobName, jobqueue[i].CPUTime, time);  
22.           
23.         Sleep(jobqueue[i].CPUTime * 100); // 模拟 CPU 时间，单位为秒  
24.         printf("作业 %s 执行完毕！\n", jobqueue[i].JobName);  
25.         // 更新当前时间  
26.         time += jobqueue[i].CPUTime;  
27.         printf("当前时间为%d\n", time);  
28.         Time = time;  
29.         printf("------------------------------------------------------------------------\n");  
30.     }  
31. }  

5.2.2 SJF短进程优先

（1）代码实现

1.自定义结构体

1. //创建JCB  
2. typedef struct {  
3.     char JobName[50];         //作业名称  
4.     int reachtime;            //作业到达时间  
5.     int CPUTime;              //CPU使用时间  
6.     int waitingTime;          //等待时间  
7.     int turnaroundTime;       //周转时间  
8. }JCBSJF;  

2.核心算法实现

1. void SJF() {  
2.     int time = 0;  
3.     for (int i = 0; i < Jobcount; i++) {    
4.         if (jobqueue[i].reachtime > time) {  
5.             time = jobqueue[i].reachtime;  
6.         }    
7.         jobqueue[i].waitingTime = time - jobqueue[i].reachtime;  
8.         jobqueue[i].turnaroundTime = jobqueue[i].waitingTime + jobqueue[i].CPUTime;  
9.         // 模拟作业执行  
10.         printf("正在执行作业: %s，所需时间: %d，当前时间: %d\n",  
11.             jobqueue[i].JobName, jobqueue[i].CPUTime, time);  
12.   
13.         Sleep(jobqueue[i].CPUTime * 100); // 模拟 CPU 时间，单位为秒  
14.         printf("作业 %s 执行完毕！\n", jobqueue[i].JobName);  
15.   
16.   
17.         // 更新当前时间  
18.         time += jobqueue[i].CPUTime;  
19.         printf("当前时间为%d\n", time);  
20.         Time = time;  
21.         printf("------------------------------------------------------------------------\n");  
22.     }  
23. } 

5.2.3 PS高优先权

（1）代码实现

1.自定义结构体

1. //创建JCB  
2. typedef struct {  
3.     char JobName[50];         //作业名称  
4.     int reachtime;            //作业到达时间  
5.     int CPUTime;              //CPU使用时间  
6.     int waitingTime;          //等待时间  
7.     int turnaroundTime;       //周转时间  
8.     int prority;          //作业优先级  
9. }JCBPS;  

2.核心算法实现

1. void PS() {  
2.     int time = 0;  
3.     for (int i = 0; i < Jobcount; i++) {  
4.   
5.         if (jobqueue[i].reachtime > time) {  
6.             time = jobqueue[i].reachtime;  
7.         }  
8.   
9.         jobqueue[i].waitingTime = time - jobqueue[i].reachtime;  
10.         jobqueue[i].turnaroundTime = jobqueue[i].waitingTime + jobqueue[i].CPUTime;  
11.         // 模拟作业执行  
12.         printf("正在执行作业: %s，所需时间: %d，当前时间: %d\n",  
13.             jobqueue[i].JobName, jobqueue[i].CPUTime, time);  
14.   
15.         Sleep(jobqueue[i].CPUTime * 100); // 模拟 CPU 时间，单位为秒  
16.         printf("作业 %s 执行完毕！\n", jobqueue[i].JobName);  
17.         // 更新当前时间  
18.         time += jobqueue[i].CPUTime;  
19.         printf("当前时间为%d\n", time);  
20.         Time = time;  
21.         printf("----------------------------------------------------------------------------------\n");  
22.     }  
23. }  

5.2.4 HRRN高响应比

（1）代码实现

1.自定义结构体

1. // 创建 JCB  
2. typedef struct {  
3.     char JobName[50];         // 作业名称  
4.     int reachtime;            // 作业到达时间  
5.     int WaitTime;             // 作业等待时间  
6.     int CPUTime;              // CPU 使用时间  
7.     int turnaroundTime;       // 周转时间  
8.     float responseRatio;      // 响应比  
9. } JCBHRRN;  

2.核心算法实现

1. // HRRN 调度算法  
2. void HRRN() {  
3.     int elapsedTime = 0; // 记录当前时间  
4.     while (Jobcount > 0) {  
5.         // 计算所有作业的响应比  
6.         CalculateResponseRatios(elapsedTime);  
7.   
8.         // 找到响应比最高的作业  
9.         int highestIndex = -1;  
10.         float highestRatio = -1.0;  
11.         for (int i = 0; i < Jobcount; i++) {  
12.             if (jobqueue[i].responseRatio > highestRatio) {  
13.                 highestRatio = jobqueue[i].responseRatio;  
14.                 highestIndex = i;  
15.             }  
16.         }  
17.   
18.         // 如果没有可执行作业（所有作业未到达），时间前进  
19.         if (highestIndex == -1) {  
20.             elapsedTime++;  
21.             continue;  
22.         }  
23.   
24.         // 执行选中的作业  
25.         JCBHRRN* job = &jobqueue[highestIndex];  
26.         printf("正在执行作业: %s, 当前时间: %d, 响应比: %.2f\n",  
27.             job->JobName, elapsedTime, job->responseRatio);  
28.         Sleep(job->CPUTime * 100); // 模拟 CPU 执行时间  
29.         elapsedTime += job->CPUTime; // 更新时间  
30.   
31.         // 计算周转时间  
32.         job->turnaroundTime = elapsedTime - job->reachtime;  
33.   
34.         printf("作业 %s 执行完毕！周转时间: %d, 等待时间: %d\n",  
35.             job->JobName, job->turnaroundTime, job->WaitTime);  
36.   
37.         // 将完成的作业加入 completedJobs 队列  
38.         completedJobs[CompletedCount++] = *job;  
39.   
40.         // 删除执行完的作业  
41.         for (int i = highestIndex; i < Jobcount - 1; i++) {  
42.             jobqueue[i] = jobqueue[i + 1];  
43.         }  
44.         Jobcount--; // 减少作业计数  
45.         printf("执行过后时间为:%d\n", elapsedTime);  
46.         endtime = elapsedTime;  
47.         printf("------------------------------------------------------------------------\n");  
48.     }  
49. }  

5.2.5 RR时间片轮转

（1）代码实现

1.自定义结构体

1. // 定义作业结构体  
2. typedef struct {  
3.     char JobName[20];   // 作业名称  
4.     int arrivalTime;    // 到达时间  
5.     int serviceTime;    // 服务时间（CPU 时间）  
6.     int remainingTime;  // 剩余服务时间  
7.     int completionTime; // 完成时间  
8.     int turnaroundTime; // 周转时间  
9.     int waitingTime;    // 等待时间  
10.     bool isCompleted;   // 是否完成  
11. } Job;  

2.核心算法实现

1. // 时间片轮转调度算法  
2. void roundRobin() {  
3.     int currentTime = 0; // 当前时间  
4.     int completedJobs = 0; // 已完成的作业数  
5.   
6.     printf("\n开始时间片轮转调度...\n");  
7.     while (completedJobs < jobCount) {  
8.         bool progress = false;  
9.         for (int i = 0; i < jobCount; i++) {  
10.             Job* job = &jobQueue[i];  
11.             // 跳过未到达或已完成的作业  
12.             if (job->arrivalTime > currentTime || job->isCompleted) {  
13.                 continue;  
14.             }  
15.   
16.             // 当前作业开始执行  
17.             progress = true;  
18.             printf("当前时间: %d, 正在执行作业: %s\n", currentTime, job->JobName);  
19.   
20.             // 模拟时间片  
21.             if (job->remainingTime > TIME_QUANTUM) {  
22.                 Sleep(TIME_QUANTUM * 100); // 模拟执行  
23.                 currentTime += TIME_QUANTUM;  
24.                 job->remainingTime -= TIME_QUANTUM;  
25.             }  
26.             else {  
27.                 Sleep(job->remainingTime * 100); // 模拟执行  
28.                 currentTime += job->remainingTime;  
29.                 job->remainingTime = 0;  
30.                 job->isCompleted = true;  
31.                 completedJobs++;  
32.                 job->completionTime = currentTime;  
33.                 job->turnaroundTime = job->completionTime - job->arrivalTime;  
34.                 job->waitingTime = job->turnaroundTime - job->serviceTime;  
35.                 printf("作业 %s 完成！当前时间: %d\n", job->JobName, currentTime);  
36.             }  
37.         }  
38.   
39.         // 若本轮无作业执行，时间前进  
40.         if (!progress) {  
41.             currentTime++;  
42.         }  
43.     }  
44.     printf("所有作业已完成。\n");  
45. }  

1. 实验结果

6.1 FSFS先来先服务

（1）创建5个作业

第一个参数是作业名称，第二个参数是作业到达时间，第三个参数是作业占用CPU的时间。

（2）打印初始状态

1. 根据到达时间对作业进行排序

1. 作业开始执行

1. 调度结果如下，其中重要参考数据为每个作业的等待时间、周转时间，以及CPU处理所有作业的时间。

6.2 SJF短进程优先

（1）创建5个作业

第一个参数是作业名称，第二个参数是作业到达时间，第三个参数是作业占用CPU的时间。

（2）打印初始状态

1. 根据cpu的使用时间对作业进行排序

1. 调度过程

1. 调度结果如下，其中重要参考数据为每个作业的等待时间、周转时间，以及CPU处理所有作业的时间。

6.3 PS高优先权

（1）创建5个作业

第一个参数是作业名称，第二个参数是作业到达时间，第三个参数是作业占用CPU的时间， 第四个参数是优先级。

（2）打印初始状态

（3）根据作业的优先级进行排序

（4）调度过程

1. 调度结果如下，其中重要参考数据为每个作业的等待时间、周转时间，以及CPU处理所有作业的时间。

6.4 HRRN高响应比

（1）创建5个作业

第一个参数是作业名称，第二个参数是作业到达时间，第三个参数是作业占用CPU的时间。

（2）打印初始状态

（3）调度过程

（4）调度结果如下，其中重要参考数据为每个作业的等待时间、周转时间，以及CPU处理所有作业的时间。

6.5 RR时间片轮转

（1）创建5个作业

第一个参数是作业名称，第二个参数是作业到达时间，第三个参数是作业占用CPU的时间。

（2）打印初始状态

1. 调度过程

1. 结果

7.源代码

7.1 FSFS先来先服务

//先来先服务调度算法
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>  // 包含 Windows 头文件

#define MAX_JOBS 10

int Time;
//创建JCB
typedef struct{
	char JobName[50];         //作业名称
	int reachtime;            //作业到达时间
	int CPUTime;              //CPU使用时间
	int waitingTime;          //等待时间
	int turnaroundTime;       //周转时间
}JCBFCFS;

//创建一个JCB列表
JCBFCFS jobqueue[MAX_JOBS];

int Jobcount = 0;

//添加作业到JCB列表
void addjob(const char JobName[], int reachtime, int CPUTime) {
	if (Jobcount < MAX_JOBS) {
		strcpy(jobqueue[Jobcount].JobName , JobName);
		jobqueue[Jobcount].reachtime = reachtime;
		jobqueue[Jobcount].CPUTime = CPUTime;
		Jobcount++;
	}
	else {
		printf("队列已满，无法操作！");
	}
}

void PrintJobs() {
	printf("作业列表:\n");
	for (int i = 0; i < Jobcount; i++) {
		printf("作业名称: %s,到达时间：%d, CPU 时间: %d, 等待时间: %d, 周转时间: %d\n",
			jobqueue[i].JobName,
			jobqueue[i].reachtime,
			jobqueue[i].CPUTime,
			jobqueue[i].waitingTime,
			jobqueue[i].turnaroundTime);
	}
}

void sortjobs() {
	JCBFCFS temp;
	for (int i = 0; i < Jobcount-1; i++) {
		for (int j = 0; j < Jobcount-i-1; j++) {
			if (jobqueue[j].reachtime > jobqueue[j + 1].reachtime) {
				temp = jobqueue[j];
				jobqueue[j] = jobqueue[j+1];
				jobqueue[j + 1] = temp;
			}
		}
	}
}


void FCFS() {
	int time = 0;
	for (int i = 0; i < Jobcount; i++) {
		
		if (jobqueue[i].reachtime > time) {
			time = jobqueue[i].reachtime;
		}
		
		jobqueue[i].waitingTime = time - jobqueue[i].reachtime;
		jobqueue[i].turnaroundTime = jobqueue[i].waitingTime + jobqueue[i].CPUTime;
		
		
		// 模拟作业执行
		printf("正在执行作业: %s，所需时间: %d，当前时间: %d\n",
			jobqueue[i].JobName, jobqueue[i].CPUTime, time);
		
		Sleep(jobqueue[i].CPUTime * 100); // 模拟 CPU 时间，单位为秒
		printf("作业 %s 执行完毕！\n", jobqueue[i].JobName);

		
		// 更新当前时间
		time += jobqueue[i].CPUTime;
		printf("当前时间为%d\n", time);
		Time = time;
		printf("------------------------------------------------------------------------\n");
	}
}

int main() {
	int n;
	printf("----------------------------------FCFS----------------------------------\n");

	addjob("job1", 0, 3);
	addjob("job2", 2, 5);
	addjob("job3", 5, 2);
	addjob("job4", 3, 1);
	addjob("job5", 7, 4);

	printf("初始状态如下：\n");
	PrintJobs();
	printf("------------------------------------------------------------------------\n");

	sortjobs();
	printf("根据到达时间排序后状态如下：\n");
	PrintJobs();
	printf("------------------------------------------------------------------------\n");

	FCFS();
	printf("------------------------------------------------------------------------\n");
	
	printf("调度后状态如下：\n");
	PrintJobs();
	printf("------------------------------------------------------------------------\n");
	printf("FCFS最终使用时间为：%d\n",Time);
	printf("------------------------------------------------------------------------\n");
	return 0;
}

7.2 SJF短进程优先

//短进程优先调度算法
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>  // 包含 Windows 头文件

#define MAX_JOBS 10
int Time;

//创建JCB
typedef struct {
	char JobName[50];         //作业名称
	int reachtime;            //作业到达时间
	int CPUTime;              //CPU使用时间
	int waitingTime;          //等待时间
	int turnaroundTime;       //周转时间
}JCBSJF;

//创建一个JCB列表
JCBSJF jobqueue[MAX_JOBS];

int Jobcount = 0;

//添加作业到JCB列表
void addjob(const char JobName[], int reachtime, int CPUTime) {
	if (Jobcount < MAX_JOBS) {
		strcpy(jobqueue[Jobcount].JobName, JobName);
		jobqueue[Jobcount].reachtime = reachtime;
		jobqueue[Jobcount].CPUTime = CPUTime;
		Jobcount++;
	}
	else {
		printf("队列已满，无法操作！");
	}
}

void PrintJobs() {
	printf("作业列表:\n");
	for (int i = 0; i < Jobcount; i++) {
		printf("作业名称: %s,到达时间：%d, CPU 时间: %d, 等待时间: %d, 周转时间: %d\n",
			jobqueue[i].JobName,
			jobqueue[i].reachtime,
			jobqueue[i].CPUTime,
			jobqueue[i].waitingTime,
			jobqueue[i].turnaroundTime);
	}
}

//根据CPU处理时间的长短来排序
void sortjobs() {
	JCBSJF temp;
	for (int i = 0; i < Jobcount - 1; i++) {
		for (int j = 0; j < Jobcount - i - 1; j++) {
			if (jobqueue[j].CPUTime > jobqueue[j + 1].CPUTime) {
				temp = jobqueue[j];
				jobqueue[j] = jobqueue[j + 1];
				jobqueue[j + 1] = temp;
			}
		}
	}
}


void SJF() {
	int time = 0;
	for (int i = 0; i < Jobcount; i++) {

		if (jobqueue[i].reachtime > time) {
			time = jobqueue[i].reachtime;
		}

		jobqueue[i].waitingTime = time - jobqueue[i].reachtime;
		jobqueue[i].turnaroundTime = jobqueue[i].waitingTime + jobqueue[i].CPUTime;


		// 模拟作业执行
		printf("正在执行作业: %s，所需时间: %d，当前时间: %d\n",
			jobqueue[i].JobName, jobqueue[i].CPUTime, time);

		Sleep(jobqueue[i].CPUTime * 100); // 模拟 CPU 时间，单位为秒
		printf("作业 %s 执行完毕！\n", jobqueue[i].JobName);


		// 更新当前时间
		time += jobqueue[i].CPUTime;
		printf("当前时间为%d\n", time);
		Time = time;
		printf("------------------------------------------------------------------------\n");
	}
}

int main() {
	int n;
	printf("----------------------------------SJF----------------------------------\n");

	addjob("job1", 0, 3);
	addjob("job2", 2, 5);
	addjob("job3", 5, 2);
	addjob("job4", 3, 1);
	addjob("job5", 7, 4);

	printf("初始状态如下：\n");
	PrintJobs();
	printf("------------------------------------------------------------------------\n");

	sortjobs();
	printf("根据处理时间排序后状态如下：\n");
	PrintJobs();
	printf("------------------------------------------------------------------------\n");

	SJF();
	printf("------------------------------------------------------------------------\n");

	printf("调度后状态如下：\n");
	PrintJobs();
	printf("------------------------------------------------------------------------\n");
	printf("SJF最终所用时间为：%d\n",Time);
	printf("------------------------------------------------------------------------\n");

	return 0;
}

7.3 PS高优先权

//高优先权调度算法
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>  // 包含 Windows 头文件

#define MAX_JOBS 10

int Time;

//创建JCB
typedef struct {
	char JobName[50];         //作业名称
	int reachtime;            //作业到达时间
	int CPUTime;              //CPU使用时间
	int waitingTime;          //等待时间
	int turnaroundTime;       //周转时间
	int prority;          //作业优先级
}JCBPS;

//创建一个JCB列表
JCBPS jobqueue[MAX_JOBS];

int Jobcount = 0;

//添加作业到JCB列表
void addjob(const char JobName[], int reachtime, int CPUTime,int prority) {
	if (Jobcount < MAX_JOBS) {
		strcpy(jobqueue[Jobcount].JobName, JobName);
		jobqueue[Jobcount].reachtime = reachtime;
		jobqueue[Jobcount].CPUTime = CPUTime;
		jobqueue[Jobcount].prority = prority;
		Jobcount++;
	}
	else {
		printf("队列已满，无法操作！");
	}
}

void PrintJobs() {
	printf("作业列表:\n");
	for (int i = 0; i < Jobcount; i++) {
		printf("作业名称: %s,到达时间：%d, CPU 时间: %d, 等待时间: %d, 周转时间: %d, 优先权为：%d\n",
			jobqueue[i].JobName,
			jobqueue[i].reachtime,
			jobqueue[i].CPUTime,
			jobqueue[i].waitingTime,
			jobqueue[i].turnaroundTime,
			jobqueue[i].prority);
	}
}

//根据优先权来排序
void sortjobs() {
	JCBPS temp;
	for (int i = 0; i < Jobcount - 1; i++) {
		for (int j = 0; j < Jobcount - i - 1; j++) {
			if (jobqueue[j].prority > jobqueue[j + 1].prority) {
				temp = jobqueue[j];
				jobqueue[j] = jobqueue[j + 1];
				jobqueue[j + 1] = temp;
			}
		}
	}
}


void PS() {
	int time = 0;
	for (int i = 0; i < Jobcount; i++) {

		if (jobqueue[i].reachtime > time) {
			time = jobqueue[i].reachtime;
		}

		jobqueue[i].waitingTime = time - jobqueue[i].reachtime;
		jobqueue[i].turnaroundTime = jobqueue[i].waitingTime + jobqueue[i].CPUTime;


		// 模拟作业执行
		printf("正在执行作业: %s，所需时间: %d，当前时间: %d\n",
			jobqueue[i].JobName, jobqueue[i].CPUTime, time);

		Sleep(jobqueue[i].CPUTime * 100); // 模拟 CPU 时间，单位为秒
		printf("作业 %s 执行完毕！\n", jobqueue[i].JobName);


		// 更新当前时间
		time += jobqueue[i].CPUTime;
		printf("当前时间为%d\n", time);
		Time = time;
		printf("----------------------------------------------------------------------------------\n");
	}
}

int main() {
	int n;
	printf("----------------------------------------PS----------------------------------------\n");

	addjob("job1", 0, 3, 2);
	addjob("job2", 2, 5, 4);
	addjob("job3", 5, 2, 3);
	addjob("job4", 3, 1, 1);
	addjob("job5", 7, 4, 5);

	printf("初始状态如下：\n");
	PrintJobs();
	printf("----------------------------------------------------------------------------------\n");

	sortjobs();
	printf("根据优先权排序后状态如下：\n");
	PrintJobs();
	printf("----------------------------------------------------------------------------------\n");

	PS();
	printf("----------------------------------------------------------------------------------\n");

	printf("调度后状态如下：\n");
	PrintJobs();
	printf("----------------------------------------------------------------------------------\n");
	
	printf("PS最终所用时间为：%d\n",Time);
	printf("----------------------------------------------------------------------------------\n");


	return 0;
}

7.4 HRRN高响应比

高响应比优先
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>  // 包含 Windows 头文件

#define MAX_JOBS 10

int endtime = 0;

// 创建 JCB
typedef struct {
    char JobName[50];         // 作业名称
    int reachtime;            // 作业到达时间
    int WaitTime;             // 作业等待时间
    int CPUTime;              // CPU 使用时间
    int turnaroundTime;       // 周转时间
    float responseRatio;      // 响应比
} JCBHRRN;

// 作业队列
JCBHRRN jobqueue[MAX_JOBS];
JCBHRRN completedJobs[MAX_JOBS]; // 存储完成的作业
int Jobcount = 0;
int CompletedCount = 0; // 已完成作业计数

// 添加作业到队列
void addjob(const char JobName[], int reachtime, int CPUTime) {
    if (Jobcount < MAX_JOBS) {
        strcpy(jobqueue[Jobcount].JobName, JobName);
        jobqueue[Jobcount].reachtime = reachtime;
        jobqueue[Jobcount].CPUTime = CPUTime;
        jobqueue[Jobcount].WaitTime = 0;
        jobqueue[Jobcount].turnaroundTime = 0;
        jobqueue[Jobcount].responseRatio = 0.0;
        Jobcount++;
    }
    else {
        printf("队列已满，无法操作！\n");
    }
}

// 打印作业信息
void PrintJobs(JCBHRRN jobs[], int count) {
    printf("作业列表:\n");
    for (int i = 0; i < count; i++) {
        printf("作业名称: %s, 到达时间: %d, CPU 时间: %d, 等待时间: %d, 周转时间: %d\n",
            jobs[i].JobName,
            jobs[i].reachtime,
            jobs[i].CPUTime,
            jobs[i].WaitTime,
            jobs[i].turnaroundTime);
    }
}

// 计算响应比
void CalculateResponseRatios(int elapsedTime) {
    for (int i = 0; i < Jobcount; i++) {
        if (jobqueue[i].reachtime <= elapsedTime) { // 作业已经到达
            jobqueue[i].WaitTime = elapsedTime - jobqueue[i].reachtime;
            jobqueue[i].responseRatio = (float)(jobqueue[i].WaitTime + jobqueue[i].CPUTime) / jobqueue[i].CPUTime;
        }
        else {
            jobqueue[i].responseRatio = -1.0; // 作业未到达，跳过
        }
    }
}

// HRRN 调度算法
void HRRN() {
    int elapsedTime = 0; // 记录当前时间
    while (Jobcount > 0) {
        // 计算所有作业的响应比
        CalculateResponseRatios(elapsedTime);

        // 找到响应比最高的作业
        int highestIndex = -1;
        float highestRatio = -1.0;
        for (int i = 0; i < Jobcount; i++) {
            if (jobqueue[i].responseRatio > highestRatio) {
                highestRatio = jobqueue[i].responseRatio;
                highestIndex = i;
            }
        }

        // 如果没有可执行作业（所有作业未到达），时间前进
        if (highestIndex == -1) {
            elapsedTime++;
            continue;
        }

        // 执行选中的作业
        JCBHRRN* job = &jobqueue[highestIndex];
        printf("正在执行作业: %s, 当前时间: %d, 响应比: %.2f\n",
            job->JobName, elapsedTime, job->responseRatio);
        Sleep(job->CPUTime * 100); // 模拟 CPU 执行时间
        elapsedTime += job->CPUTime; // 更新时间

        // 计算周转时间
        job->turnaroundTime = elapsedTime - job->reachtime;

        printf("作业 %s 执行完毕！周转时间: %d, 等待时间: %d\n",
            job->JobName, job->turnaroundTime, job->WaitTime);

        // 将完成的作业加入 completedJobs 队列
        completedJobs[CompletedCount++] = *job;

        // 删除执行完的作业
        for (int i = highestIndex; i < Jobcount - 1; i++) {
            jobqueue[i] = jobqueue[i + 1];
        }
        Jobcount--; // 减少作业计数
        printf("执行过后时间为:%d\n", elapsedTime);
        endtime = elapsedTime;
        printf("------------------------------------------------------------------------\n");
    }
}

int main() {
    printf("----------------------------------HRRN----------------------------------\n");

    addjob("job1", 0, 3);
    addjob("job2", 2, 5);
    addjob("job3", 5, 2);
    addjob("job4", 3, 1);
    addjob("job5", 7, 4);

    printf("初始状态如下：\n");
    PrintJobs(jobqueue, Jobcount);
    printf("------------------------------------------------------------------------\n");

    HRRN();

    printf("所有作业已完成！\n");
    printf("------------------------------------------------------------------------\n");
    printf("最终作业状态如下：\n");
    PrintJobs(completedJobs, CompletedCount);
    printf("------------------------------------------------------------------------\n");
    printf("HRRN最终使用时间为：");
    printf("%d\n", endtime);
    printf("------------------------------------------------------------------------\n");
    return 0;
}

7.5  RR时间片轮转

//时间片轮转调度算法
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <windows.h> // 为了使用 Sleep 函数模拟执行

#define MAX_JOBS 10
#define TIME_QUANTUM 4 // 时间片大小为 4 ms

// 定义作业结构体
typedef struct {
    char JobName[20];   // 作业名称
    int arrivalTime;    // 到达时间
    int serviceTime;    // 服务时间（CPU 时间）
    int remainingTime;  // 剩余服务时间
    int completionTime; // 完成时间
    int turnaroundTime; // 周转时间
    int waitingTime;    // 等待时间
    bool isCompleted;   // 是否完成
} Job;

Job jobQueue[MAX_JOBS];
int jobCount = 0;

// 添加作业
void addjob(const char* name, int arrivalTime, int serviceTime) {
    if (jobCount < MAX_JOBS) {
        strcpy(jobQueue[jobCount].JobName, name);
        jobQueue[jobCount].arrivalTime = arrivalTime;
        jobQueue[jobCount].serviceTime = serviceTime;
        jobQueue[jobCount].remainingTime = serviceTime;
        jobQueue[jobCount].completionTime = 0;
        jobQueue[jobCount].turnaroundTime = 0;
        jobQueue[jobCount].waitingTime = 0;
        jobQueue[jobCount].isCompleted = false;
        jobCount++;
    }
    else {
        printf("作业队列已满，无法添加作业。\n");
    }
}

// 打印作业状态
void printJobs() {
    printf("作业状态:\n");
    printf("名称\t到达\t服务\t完成\t周转\t等待\n");
    for (int i = 0; i < jobCount; i++) {
        printf("%s\t%d\t%d\t%d\t%d\t%d\n",
            jobQueue[i].JobName,
            jobQueue[i].arrivalTime,
            jobQueue[i].serviceTime,
            jobQueue[i].completionTime,
            jobQueue[i].turnaroundTime,
            jobQueue[i].waitingTime);
    }
}

// 时间片轮转调度算法
void roundRobin() {
    int currentTime = 0; // 当前时间
    int completedJobs = 0; // 已完成的作业数

    printf("\n开始时间片轮转调度...\n");
    while (completedJobs < jobCount) {
        bool progress = false;
        for (int i = 0; i < jobCount; i++) {
            Job* job = &jobQueue[i];
            // 跳过未到达或已完成的作业
            if (job->arrivalTime > currentTime || job->isCompleted) {
                continue;
            }

            // 当前作业开始执行
            progress = true;
            printf("当前时间: %d, 正在执行作业: %s\n", currentTime, job->JobName);

            // 模拟时间片
            if (job->remainingTime > TIME_QUANTUM) {
                Sleep(TIME_QUANTUM * 100); // 模拟执行
                currentTime += TIME_QUANTUM;
                job->remainingTime -= TIME_QUANTUM;
            }
            else {
                Sleep(job->remainingTime * 100); // 模拟执行
                currentTime += job->remainingTime;
                job->remainingTime = 0;
                job->isCompleted = true;
                completedJobs++;
                job->completionTime = currentTime;
                job->turnaroundTime = job->completionTime - job->arrivalTime;
                job->waitingTime = job->turnaroundTime - job->serviceTime;
                printf("作业 %s 完成！当前时间: %d\n", job->JobName, currentTime);
            }
        }

        // 若本轮无作业执行，时间前进
        if (!progress) {
            currentTime++;
        }
    }
    printf("所有作业已完成。\n");
}

int main() {
    // 添加作业
	addjob("job1", 0, 3);
	addjob("job2", 2, 5);
	addjob("job3", 5, 2);
	addjob("job4", 3, 1);
	addjob("job5", 7, 4);

    // 打印初始作业状态
    printf("初始作业状态:\n");
    printJobs();

    // 调用时间片轮转调度算法
    roundRobin();

    // 打印最终作业状态
    printf("\n最终作业状态:\n");
    printJobs();

    return 0;
}