【操作系统】使用C/C++实现进程调度算法

最新推荐文章于 2024-08-09 23:20:37 发布
最新推荐文章于 2024-08-09 23:20:37 发布
阅读量3.4k 收藏 56
点赞数 10
分类专栏： 算法 文章标签： 算法 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ruvikm/article/details/109807042
版权

使用C/C++实现进程调度算法

1 先来先服务调度算法
2 优先级调度算法
3 短作业（或进程）优先调度算法
4 响应比高优先调度算法

测试数据：

id reachtime dotime privilege
1 70 20 1
2 80 10 3
3 85 20 4
4 90 5 2

代码：

#define _CRT_SECURE_NO_WARNINGS   //解决VS报错
#include<stdio.h>
#include<stdlib.h>
//#include<conio.h>
#include<time.h>
#include<memory.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<iostream>
#define getpch(type) (type*)malloc(sizeof(type))
#define inf 0x3f3f3f
using namespace std;

//定义作业信息结构
typedef struct node {
	int number;         //作业号
	int reach_time;     //作业抵达时间
	int need_time;      //作业的执行时间
	int privilege;	    //作业优先权
	float excellent;    //响应比
	int start_time;     //作业开始时间
	int wait_time;      //等待时间
	int tr_time;        //周转时间
	double wtr_time;    //带权周转时间
	int run_time;       //作业累计已执行时间
	bool visited;		//作业是否被访问过
	int finish_time; //作业完成时间
	bool reached; //作业是否抵达
}job;

//停顿几秒
void _sleep(int n) {
	clock_t goal;
	goal = (clock_t)n * CLOCKS_PER_SEC + clock();
	while (goal > clock());
}

//按任意键继续
char _keygo() {
	char c;
	printf("Press any key to continue...\n");
	c = getchar();
	return c;
}

//数据设置区域

const int MAX_NUM = 100;//最大作业数量
const int MAX_LINE = 1024;//一行的size
int num = 0;//实际作业数量
job jobs[MAX_NUM];//作业
//就绪队列
int ready[MAX_NUM];
//记录排序使用哪个数值作为排序对象
int order[MAX_NUM];
void initial_jobs() { //初始化所有作业信息
	for (int i = 0; i < MAX_NUM; i++)
	{
		jobs[i].excellent = 0;
		jobs[i].need_time = 0;
		jobs[i].number = 0;
		jobs[i].privilege = 0;
		jobs[i].reach_time = 0;
		jobs[i].run_time = 0;
		jobs[i].start_time = 0;
		jobs[i].tr_time = 0;
		jobs[i].visited = false;
		jobs[i].wait_time = 0;
		jobs[i].wtr_time = 0;
		jobs[i].finish_time = 0;
		jobs[i].reached = false;
	}
}
void read_Jobdata() { //读取数据文件
	FILE* fp;
	fp = fopen("./test.txt", "r");
	if (fp == NULL) {  //如果文件不存在，则退出
		printf("fail to open the file!\n");
		exit(0);
	}
	char buffer[100];
	printf("start reading...\n");
	fgets(buffer, MAX_LINE, fp);
	cout << buffer;
	num = 0;
	num++;
	while (!feof(fp)) {
		fscanf(fp, "%d%d%d%d", &jobs[num].number, &jobs[num].reach_time, &jobs[num].need_time, &jobs[num].privilege);
		//cout<<jobs[num].number<<" "<<jobs[num].reach_time<<" "<<jobs[num].need_time<<" "<<jobs[num].privilege<<endl;
		num++;
	}
	num--;
	printf("read data success!\n");
	printf("The number of jobs is: %d\n", num);
	printf("%s\n", buffer);
	for (int j = 1; j <= num; j++)
	{
		printf("%d\t%d\t\t%d\t\t%d\n", jobs[j].number, jobs[j].reach_time, jobs[j].need_time, jobs[j].privilege);
	}
	fclose(fp);
}
void initial_jobs_again()
{
	for (int i = 1; i <= num; i++) {
		jobs[i].finish_time = 0;
		jobs[i].excellent = 0;
		jobs[i].tr_time = 0;
		jobs[i].wtr_time = 0;
		jobs[i].wait_time = 0;
		jobs[i].visited = false;
	}
}

//调度函数

//先来先服务算法
void FCFS() {
	int i, j, temp;
	double sum1 = 0; //总的等待时间
	double sum2 = 0; //总的周转时间
	double sum3 = 0; //总的带权周转时间
	for (i = 1; i <= num; i++) {
		order[i] = jobs[i].reach_time;
		ready[i] = i;
	}
	//冒泡排序
	for (i = 1; i <= num; i++) {//按照到达时间大小排序
		for (j = 1; j <= num - i; j++) {
			if (order[j] > order[j + 1]) {
				temp = order[j];
				order[j] = order[j + 1];
				order[j + 1] = temp;
				temp = ready[j];
				ready[j] = ready[j + 1];
				ready[j + 1] = temp;
			}
		}
	}
	for (i = 1; i <= num; i++) {
		printf("%dth work", ready[i]);
		printf("arrival time --%d,service hours--%d\n",
			jobs[ready[i]].reach_time,
			jobs[ready[i]].need_time);
		printf("This job is running...........\n");
		_sleep(1);
		printf("Finished running\n");
		if (i == 1) {
			jobs[ready[i]].finish_time = jobs[ready[i]].reach_time + jobs[ready[i]].need_time;
			jobs[ready[i]].wait_time = 0;
		}
		else {
			if (jobs[ready[i - 1]].finish_time > jobs[ready[i]].reach_time) {  //如果上一个作业的完成时间大于下一个作业的到达时间，则下一个作业的开始时间从上一个的完成时间开始
				jobs[ready[i]].finish_time = jobs[ready[i - 1]].finish_time + jobs[ready[i]].need_time;
				jobs[ready[i]].wait_time = jobs[ready[i - 1]].finish_time - jobs[ready[i]].reach_time;
			}
			else {
				jobs[ready[i]].finish_time = jobs[ready[i]].need_time + jobs[ready[i]].reach_time;
				jobs[ready[i]].wait_time = 0;
			}
		}
		jobs[ready[i]].tr_time = jobs[ready[i]].finish_time - jobs[ready[i]].reach_time;
		jobs[ready[i]].wtr_time = double(jobs[ready[i]].tr_time) / jobs[ready[i]].need_time;
		printf("waiting time: %d Turnaround time: %d Weighted turnaround time: %0.2f\n", jobs[ready[i]].wait_time, jobs[ready[i]].tr_time, jobs[ready[i]].wtr_time);
		sum1 += jobs[ready[i]].wait_time;
		sum2 += jobs[ready[i]].tr_time;
		sum3 += jobs[ready[i]].wtr_time;
	}
	printf("--------All jobs are scheduled------\n");
	printf("Average waiting time: %.2f Average turnaround time: %.2f Average weighted turnaround time: %.2f", sum1 / num, sum2 / num, sum3 / num);
	initial_jobs_again();
}
int findNextSJF(job j[MAX_NUM], int length, int time) {
	// p是已经到达且拥有最短运行时间的进程的下标
	// q是没有到达的进程中拥有最早到达时间的进程的下标
	int i, p, q;
	int minNeedTime, minReachTime, minTime;
	p = q = -1; minTime = minNeedTime = minReachTime = inf;
	for (i = 1; i <= length; i++) {
		if (!j[i].visited) {
			// 第一情况
			if (j[i].reach_time <= time && j[i].need_time <= minNeedTime)
			{
				p = i; minNeedTime = j[i].need_time;
			}
			// 第二种情况
			else if (j[i].reach_time > time && j[i].reach_time <= minReachTime) {
				if (j[i].need_time < minTime)
				{
					q = i; minReachTime = j[i].reach_time; minTime = j[i].need_time;
				}
			}
		}
	}
	// p为-1时,代表在lastTime时刻还没进程到达,此时选择下一个最早到达的进程q
	if (p != -1) return p;
	return q;
}

//短作业优先算法
void SJF() {
	int i, j;
	double sum1 = 0; //总的等待时间
	double sum2 = 0; //总的周转时间
	double sum3 = 0; //总的带权周转时间
	int finish = inf; //当前完成时间
	for (i = 1; i <= num; i++) {
		finish = min(finish, jobs[i].reach_time);
	}
	printf("Short job priority algorithm: \n");
	for (i = 1; i <= num; i++) {
		int index = findNextSJF(jobs, num, finish);
		printf("%dth work", index);
		printf("Arrival time --%d,service hours--%d\n",
			jobs[index].reach_time,
			jobs[index].need_time);
		printf("This job is running...........\n");
		_sleep(1);
		printf("Finished running\n");
		if (jobs[index].reach_time <= finish) {
			jobs[index].wait_time = finish - jobs[index].reach_time;
			jobs[index].start_time = finish;
		}
		else {
			jobs[index].start_time = jobs[index].reach_time;
			jobs[index].wait_time = 0;
		}
		jobs[index].finish_time = jobs[index].start_time + jobs[index].need_time;
		jobs[index].tr_time = jobs[index].finish_time - jobs[index].reach_time;
		jobs[index].wtr_time = (double)jobs[index].tr_time / jobs[index].need_time;
		jobs[index].visited = true;
		sum1 += jobs[index].wait_time;
		sum2 += jobs[index].tr_time;
		sum3 += jobs[index].wtr_time;
		finish = jobs[index].finish_time;
		printf("waiting time: %d Turnaround time: %d Weighted turnaround time: %0.2f\n", jobs[index].wait_time, jobs[index].tr_time, jobs[index].wtr_time);
	}
	printf("--------All jobs are scheduled------\n");
	printf("Average waiting time: %.2f Average turnaround time: %.2f Average weighted turnaround time: %.2f", sum1 / num, sum2 / num, sum3 / num);
	initial_jobs_again();
}
int findNextHRRF(int pre)
{
	int current = 1, i, j;    //优先权=(等待时间+要求服务时间)/要求服务时间
	for (i = 1; i <= num; i++)
	{
		if (!jobs[i].visited) {
			jobs[i].wait_time = jobs[pre].finish_time - jobs[i].reach_time;    //等待时间=上一个进程的完成时间-到达时间
			jobs[i].excellent = (float)(jobs[i].wait_time + jobs[i].need_time) / jobs[i].need_time;
		}
	}
	for (i = 1; i <= num; i++)
	{
		if (!jobs[i].visited)
		{
			current = i;    //找到第一个还没完成的作业
			break;
		}
	}
	for (j = i; j <= num; j++)    //和后面的作业比较
	{
		if (!jobs[j].visited)    //还没完成（运行）
		{
			if (jobs[current].reach_time < jobs[pre].finish_time)    //如果进程在上一个进程完成之前到达
			{
				if (jobs[j].excellent > jobs[current].excellent)
					current = j;    //找出到达时间在上一个进程完成之前，优先权高的进程
			}
			else    //如果进程是在上一个进程完成之后到达
			{
				if (jobs[j].reach_time < jobs[current].reach_time)
					current = j;    //找出比较早到达的一个
				else if (jobs[j].reach_time == jobs[current].reach_time && jobs[j].excellent > jobs[current].excellent)    //如果同时到达
					current = j;    //找出服务时间比较短的一个
			}
		}
	}
	return current;    //返回当前进程
}
//高相应比优先
void HRRF() {
	int i, j;
	double sum1 = 0; //总的等待时间
	double sum2 = 0; //总的周转时间
	double sum3 = 0; //总的带权周转时间
	printf("High response ratio priority scheduling algorithm: \n");
	int pre = 1;
	jobs[1].finish_time = 0;

	for (i = 1; i <= num; i++) {
		int index = findNextHRRF(pre);
		printf("%dth work", index);
		printf("Arrival time --%d,service hours--%d\n",
			jobs[index].reach_time,
			jobs[index].need_time);
		printf("This job is running...........\n");
		_sleep(1);
		printf("Finish running\n");
		if (i == 1) {
			jobs[index].start_time = jobs[index].reach_time;
			jobs[index].finish_time = jobs[index].start_time + jobs[index].need_time;
			jobs[index].tr_time = jobs[index].need_time;
			jobs[index].wtr_time = 1.00;
			jobs[index].wait_time = 0;
		}
		else {
			if (jobs[index].reach_time > jobs[pre].finish_time) {
				jobs[index].wait_time = 0;
				jobs[index].start_time = jobs[index].reach_time;
			}
			else {
				jobs[index].start_time = jobs[pre].finish_time;
				jobs[index].wait_time = jobs[pre].finish_time - jobs[index].reach_time;
			}
			jobs[index].finish_time = jobs[index].start_time + jobs[index].need_time;
			jobs[index].tr_time = jobs[index].finish_time - jobs[index].reach_time;
			jobs[index].wtr_time = (double)jobs[index].tr_time / jobs[index].need_time;
		}
		jobs[index].visited = true;
		pre = index;
		sum1 += jobs[index].wait_time;
		sum2 += jobs[index].tr_time;
		sum3 += jobs[index].wtr_time;
		printf("waiting time: %d Turnaround time: %d Weighted turnaround time: %0.2f\n", jobs[index].wait_time, jobs[index].tr_time, jobs[index].wtr_time);
	}
	printf("--------All jobs are scheduled------\n");
	printf("Average waiting time: %.2f Average turnaround time: %.2f Average weighted turnaround time: %.2f", sum1 / num, sum2 / num, sum3 / num);
	initial_jobs_again();
}
//按照先来先服务并使用时间片轮转
vector<job> jobList;     //jobList向量

int time_unit = 10;//时间片长度
void initial_job_List() {    //给向量初始化
	for (int i = 1; i <= num; i++)
	{
		jobList.push_back(jobs[i]);
	}
}
bool cmp(job a, job b)
{
	return a.reach_time < b.reach_time;
}
void RR() {
	double sum1 = 0; //总的等待时间
	double sum2 = 0; //总的周转时间
	double sum3 = 0; //总的带权周转时间
	initial_job_List();
	queue<job>Ready;     //就绪队列
	sort(jobList.begin(), jobList.end(), cmp);
	int begin = (*jobList.begin()).reach_time;
	Ready.push(*jobList.begin());
	jobList.erase(jobList.begin());
	while (!jobList.empty() || !Ready.empty()) {
		while (!jobList.empty() && begin >= (*jobList.begin()).reach_time) { 	//有新作业到达，加入就绪队列
			Ready.push(*jobList.begin());
			jobList.erase(jobList.begin());
		}
		if (Ready.front().finish_time + time_unit < Ready.front().need_time) { 	//时间片用完没运行完,加入队尾
			printf("%d th Job executed %d\n", Ready.front().number, time_unit);
			Ready.front().finish_time += time_unit;
			begin += time_unit;
			while (!jobList.empty() && begin >= (*jobList.begin()).reach_time) { 	//有新作业到达，加入就绪队列
				Ready.push(*jobList.begin());
				jobList.erase(jobList.begin());
			}

			Ready.push(Ready.front());
			Ready.pop();
			_sleep(1);
		}
		else { //作业运行完
			if (Ready.front().need_time - Ready.front().finish_time < time_unit) {
				time_unit -= Ready.front().need_time - Ready.front().finish_time;
			}
			else {
				time_unit = 10;
			}
			printf("%d th Job executed %d\n", Ready.front().number, time_unit);
			begin += time_unit;
			Ready.front().finish_time = begin;
			Ready.front().wait_time = Ready.front().finish_time - Ready.front().reach_time - Ready.front().need_time;
			Ready.front().tr_time = Ready.front().finish_time - Ready.front().reach_time;
			Ready.front().wtr_time = (double)Ready.front().tr_time / Ready.front().need_time;
			sum1 += Ready.front().wait_time;
			sum2 += Ready.front().tr_time;
			sum3 += Ready.front().wtr_time;
			printf("The finished job is %d th work，waiting time is %d ,Turnaround time is %d ,Weighted turnaround time is %.2f\n", Ready.front().number, Ready.front().wait_time
				, Ready.front().tr_time, Ready.front().wtr_time);
			//从就绪队列中移除作业
			Ready.pop();

			if (Ready.empty() && !jobList.empty()) {
				sort(jobList.begin(), jobList.end(), cmp);
				printf("Find the current earliest job is: %d\n", (*jobList.begin()).number);
				begin = (*jobList.begin()).reach_time;
			}
			if (time_unit < 10) {
				time_unit = 10;
			}
			_sleep(1);
		}
	}
	printf("--------All jobs are scheduled------\n");
	printf("Average waiting time: %.2f Average turnaround time: %.2f Average weighted turnaround time: %.2f", sum1 / num, sum2 / num, sum3 / num);
	initial_jobs_again();
}
int findNextHPF(job j[MAX_NUM], int length, int time) {
	//优先值越低 表示优先权越高
	// p是已经到达且拥有最高优先权的进程的下标
	// q是没有到达的进程中拥有最早到达时间的进程的下标
	int i, p, q;
	int minReachTime, minPrivilege1;
	p = q = -1; minPrivilege1 = minReachTime = inf;
	for (i = 1; i <= length; i++) {
		if (!j[i].visited) {
			// 第一情况
			if (j[i].reach_time <= time && j[i].privilege <= minPrivilege1)
			{
				if (j[i].privilege == j[p].privilege) {   //如果优先权一致 则按最早抵达时间
					if (j[i].reach_time < j[p].reach_time) {
						p = i;
					}
				}
				else {
					p = i;
					minPrivilege1 = j[i].privilege;
				}
			}
			// 第二种情况
			else if (j[i].reach_time > time && j[i].reach_time <= minReachTime) {
				q = i; minReachTime = j[i].reach_time;
			}
		}
	}
	// p为-1时,代表在time时刻还没进程到达,此时选择下一个最早到达的进程q
	if (p != -1) return p;
	return q;
}
//优先权高者优先
void HPF() {
	int i, j;
	double sum1 = 0; //总的等待时间
	double sum2 = 0; //总的周转时间
	double sum3 = 0; //总的带权周转时间
	int finish = inf; //当前完成时间
	for (i = 1; i <= num; i++) {
		finish = min(finish, jobs[i].reach_time);
	}
	printf("High priority priority service (non-preemptive): \n");
	for (i = 1; i <= num; i++) {
		int index = findNextHPF(jobs, num, finish);
		printf("%dth work", index);
		printf("Arrival time --%d,service hours--%d\n",
			jobs[index].reach_time,
			jobs[index].need_time);
		printf("This job is running...........\n");
		_sleep(1);
		printf("Finish running\n");
		if (jobs[index].reach_time <= finish) {
			jobs[index].wait_time = finish - jobs[index].reach_time;
			jobs[index].start_time = finish;
		}
		else {
			jobs[index].start_time = jobs[index].reach_time;
			jobs[index].wait_time = 0;
		}
		jobs[index].finish_time = jobs[index].start_time + jobs[index].need_time;
		jobs[index].tr_time = jobs[index].finish_time - jobs[index].reach_time;
		jobs[index].wtr_time = (double)jobs[index].tr_time / jobs[index].need_time;
		jobs[index].visited = true;
		sum1 += jobs[index].wait_time;
		sum2 += jobs[index].tr_time;
		sum3 += jobs[index].wtr_time;
		finish = jobs[index].finish_time;
		printf("waiting time: %d Turnaround time: %d Weighted turnaround time: %0.2f\n", jobs[index].wait_time, jobs[index].tr_time, jobs[index].wtr_time);
	}
	printf("--------All jobs are scheduled------\n");
	printf("Average waiting time: %.2f Average turnaround time: %.2f Average weighted turnaround time: %.2f", sum1 / num, sum2 / num, sum3 / num);
	initial_jobs_again();
}

/主函数
int main() {
	initial_jobs(); //初始化所有作业信息
	read_Jobdata(); //读取数据文件
	int choice = 1;

	while (choice != 0) {
		printf("\nPlease select one of the scheduling algorithms:\n");
		printf("(1)FCFS\n");
		printf("(2)SJF\n");
		printf("(3)HRRF\n");
		printf("(4)HPF\n");
		printf("(0)Exit\n");
		printf("Please enter a number：");
		scanf("%d", &choice);
		switch (choice) {
		case 1:FCFS(); break;
		case 2:SJF(); break;
		case 3:HRRF(); break;
		case 4:HPF(); break;
		case 5:RR(); break;
		case 0:printf("Exit the program\n"); break;
		}
	}
	_keygo();
}

代码里有详细注释，测试文件要和源代码放在同一目录下：
eg
运行截图：

1
2
3
4

Otto_1027
关注
专栏目录
C/C++ 进程调度算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-29 7689
优点是能够灵活调整进程的执行顺序，缺点是可能出现优先级反转的问题，即低优先级的进程一直无法执行。优点是平均等待时间较短，缺点是无法预测作业的执行时间，可能出现长作业等待时间过长的情况，且容易受到“饥饿”现象影响。进程调度算法的实现原理是根据不同的调度策略和规则，按照一定的调度算法进行进程的选择和分配。进程调度算法是操作系统中的重要组成部分，其作用是决定进程在系统资源上的分配和调度顺序。用户需要输入时间片的大小和每个进程的执行时间，然后程序会按照时间片轮转的方式进行调度，输出每个进程的执行情况。
C++编程实现进程调度算法（FCFS+RR）
热门推荐
Yuhan2001的CSDN博客
12-04 1万+
操作系统的课程实验，C++编程实现进程调度算法（FCFS和RR）
进程调度模拟算法C++实现
06-03
在Vc6.0下实现的一个进程调度模拟算法，是我们操作系统课程的课设。里面有源码和文档报告。希望对大家有帮助。
进程调度算法的C++实现
qq_41996851的博客
05-20 1826
转载：https://blog.csdn.net/li1615882553/article/details/80553945 时间片自己写的注释： #include <iostream> #include <queue> #include <algorithm> #include <cstdio> #include <cstring> u...
c++实现操作系统进程调度（四种方式）操作系统实习项目
最新发布
qq_20243443的博客
08-09 319
包含先来先服务、抢占式最短作业优先、时间片轮转、优先数调度算法。
操作系统进程调度C++代码实现
05-25
目的: 在进程控制、请求分页存储器管理、设备管理基础上 实现按先来先服务 FCFS 、短作业优先 SJF 以及时间片 轮转算法调度进程的模拟过程 。 内容 1.在第 1 3 部分基础上扩展； 2.支持 FCFS 、短 作业优先以及时间片调度算法。 3.能够较方便地查看调度过程及平均周转时间、平均带权周转时 间。 4.支持优先权调度算法与其它算法相结合的调度模式。 5.调度时应适当输出调度过程中各进程状态队列的变化情况以及进程的已执行时 间、还需服务时间（针对时间片轮转算法）。 6.完成银行家算法的实现。
进程调度算法 C++实现
ucler的博客
07-28 1304
操作系统模拟之进程调度算法。 文件共2份，其中1份cpp，1份.h，代码如下： main.cpp #include "init.h" int main() { printf("欢迎进入演示系统！\n"); printf("\n现在需要对进程数据初始化\n"); printf("通过键盘输入请输入1\n"); printf("通过构造函数直接生成请输入2\n"); int num_initialize; scanf("%d", &num_initialize); printf("\n"
【计算机操作系统】进程调度算法的 C++ 实现（附源码）
Coder Yang
06-11 6461
文章目录一、实验目的二、实验内容2.1 优先权法和轮转法2.2 算法描述三、流程图3.1 优先权法3.2 轮转法四、实验要求五、设计思想5.1 总体思想5.2 数据结构5.3 关键代码解析六、代码实现七、源码地址 一、实验目的   多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略来决定那个进程优先占有处理机。因而引起进程调度。本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。 二、实验内容 2.1 优先权法和轮转法 简化假设 1）进程为计算型的（无I/O） 2）进程状态
操作系统实验一报告【使用C语言/C++实现时间片轮转调度算法】
02-27
### 操作系统实验一报告——使用C语言/C++实现时间片轮转调度算法 #### 实验背景与目的 本实验旨在通过编程实践的方式，加深学生对于操作系统中的进程调度机制及其核心算法之一——时间片轮转（Round Robin, RR）...
操作系统八大调度算法c/c++实现
01-22
本主题将详细探讨操作系统中的八大调度算法，并结合C/C++实现进行讲解。 1. **先来先服务（FCFS，First-Come First-Served）算法**：这是一种简单的调度策略，按照进程到达的顺序分配CPU。FCFS算法实现简单，但可能...
操作系统-------进程调度算法(C++实现)
M_GSir的博客
11-10 6596
(1)    优先数法 进程就绪队列按优先数大小从高到低排列，链首进程首先投入运行。进程每执行一次，进程需要的时间片数减1、该进程的优先数减3。这样，该进程如果在一个时间片中没有完成，其优先数降低一级。接着仍是用该进程降低一级后的优先数与就绪队列中链首进程的优先数进行比较，如果仍是该进程的优先数高或相同，便让该进程继续执行；否则，调度就绪队列的链首进程投入运行。原运行过的进程按其现行优先数大小插
C++实现进程调度的算法
12-01
C++实现进程调度的算法
操作系统实验：处理器调度作业（有界面 QT 可视化）
07-14
处理器调度作业 1、实验目的：熟悉使用各种单处理器调度的各种算法，加深对于处理机调度机制的理解。练习模拟算法的编程技巧，锻炼分析试验数据的能力。 2、实验说明：随机给出一个进程调度实例，如： 进程 到达时间 服务时间 A 0 3 B 2 6 C 4 4 D 6 5 E 8 2 模拟进程调度，给出按照算法先来先服务 FCFS、轮转 RR（q=1）、最短进程优先SJF、最高响应比优先HRN 进行调度各进程的完成时间、周转时间、带权周转时间。
操作系统 进程调度 c++
05-10
Windows operating system操作系统进程调度基本实验代码
进程调度的设计与实现代码C++
05-11
操作实验一：进程调度的设计与实现的源代代码C++，要的童鞋抱走
c++实现进程调度的模拟
04-22
利用c++模拟进程的调度。模拟操作系统内核对进程的控制和管理：包括进程的创建和撤销、进程状态的切换和简单的内存空间管理。  能够模拟进程的创建与撤销过程；（4 分）  对进程的状态进行全面的控制；（4 分）  按先进先出方式管理就绪和阻塞队列，按队列输出进程状态 （2 分）  完成可变分区的分配与回收 （3 分）  界面清晰友好 （2 分）  实验结束后撰写实验报告（5 分）。
操作系统_进程调度算法C/C++语言实现
赵满刚的博客
11-29 4126
操作系统课程实验，C/C++实现四种进程调度算法。包括先到先执行、优先级原则、短作业优先、时间片轮转。本篇主要讲述整体框架及几个调度算法的具体实现。之所以说是C/C++是因为程序整体框架为C结构化没有使用面向对象。但是使用了c++标准输入输出以及c++标准库里的queue队列 一、整体框架 整体框架流程图 二、调度算法实现 四种调度算法不懂的可以参考此篇［操作系统］调度...
操作系统进程调度优先级算法 —— C++实现
枯木何日可逢春
10-19 3668
实验目的 用C++编写一个进程调度模拟程序，使用优先级或时间片轮转法实现进程调度。 实验内容 1）设计有5个进程并发执行的模拟调度程序，每个程序由一个PCB表示。 2）模拟调度程序可任选两种调度算法之一实现。 3）程序执行中应能在屏幕上显示出各进程的状态变化，以便于观察调度的整个过程。 流程图 优先级调度算法代码 #include<bits/stdc++.h> using namespace std; typedef struct PCB{ int id; int prior; int
C++实现优先进程调度算法源代码+实验报告
12-26
C++实现优先进程调度算法源代码+实验报告：计算机操作系统课程综合性实验报告-进程调度算法程序设计。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Otto_1027

蟹蟹你，我会继续努力的~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值