操作系统进程调度算法 C++

已于 2024-01-01 23:03:26 修改
阅读量1.9k 收藏 58
点赞数 6
文章标签： 算法 数据结构
于 2022-12-01 14:34:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31605553/article/details/128131176
版权

使用C和C++实现的简单的操作系统进程调度算法

1.使用的数据结构

//PCB数据结构 
struct PCB{
	long id;
	int priority=1;
	long start;
	long runtime; 
	long usedtime; 
	long end; 
	void create(long i,long st,long rt){
		id=i;
		start=st;
		runtime=rt;
	}
	void selected(long now){
		printf("(%02d:%02d) select process %d,need:%-3d,used:%-3d\n",now/60,now%60,id,runtime,usedtime);
	}
	void run(long now){
		//printf("(%02d:%02d) process %d run,need:%-3d,used:%-3d++\n",now/60,now%60,id,runtime,usedtime);
		usedtime++;
	}
}P[10010];

2.构造测试用例

//构建测试用例
map<long,long> mp;
void initPCS(){
	//默认
	long start[6]={0,8*60,8*60+20,8*60+25,8*60+30,8*60+35};
	long runtimes[6]={0,25,10,20,20,15};
	memset(P,0,5*sizeof(PCB)); 
	for(long id=1;id<=5;id++){
		P[id].create(id,start[id],runtimes[id]);
		mp[ start[id] ]=id;
	}
}

3.先来先服务

3.1流程

3.2代码实现

//FCFS算法
void FCFS(){
	long now=8*60;//定义初始时间 08:00
	const long end=12*60;//定义终止时间 12:00
	
	queue<int> wait;//等待队列
	long id;//运行进程的ID
	bool status=0;//运行进程的状态(0:结束)
	
	if(mp.find(now)!=mp.end()){//有进程创建 
		long id=mp[now];
		wait.push(id);//放入wait队列 
	}
	while(now<end){
		if(status){//进程尚未运行结束 
			P[id].run(now); 
			now++;
			if(mp.find(now)!=mp.end()){//有进程创建
				wait.push(mp[now]);//放入wait队列
			}
			if(P[id].runtime==P[id].usedtime){//运行结束 
				P[id].end=now;
				status=0;//运行状态修改为：运行结束 
			}
			continue;
		}
		if(wait.size()!=0){
			id=wait.front();//选出先来的(队头)
			wait.pop();
			status=1;//运行状态修改为：运行中
			P[id].selected(now);//打印日志 
		}else{
			now++;
			if(mp.find(now)!=mp.end()){//有进程创建
				wait.push(mp[now]);//放入wait队列
			}
			continue;
		}
	}
}

3.3运行结果

4.短作业优先算法

4.1流程

短作业优先与先来先服务唯一的不同在于：短作业优先在选择作业时需要去作业中寻找最短者

4.2代码实现

//SJF算法(非抢占式)
void SJF(){
	long now=8*60;//定义初始时间
	const long end=12*60;//定义终止时间 
	
	long id;//运行进程的ID 
	vector<int> wait;//等待队列
	bool status=0;//运行进程的状态(0:结束)
	
	if(mp.find(now)!=mp.end()){//有进程创建 
		wait.push_back(mp[now]);//放入wait队列 
	}
	while(now<end){
		if(status){//进程尚未运行结束 
			P[id].run(now); 
			now++;
			if(mp.find(now)!=mp.end()){//有进程创建
				wait.push_back(mp[now]);//放入wait队列
			}
			if(P[id].runtime==P[id].usedtime){//运行结束 
				P[id].end=now;
				status=0;//运行状态修改为：运行结束 
			}
			continue;
		}
		if(wait.size()!=0){
			
			//找到最短的进程 
			long surplus=(1<<16);
			int itmp;
			for(int i=0;i<wait.size();i++){
				long s=P[ wait[i] ].runtime;
				if(s<surplus){
					surplus=s;
					itmp=i;
				}
			}
			id=wait[itmp];
			wait.erase(wait.begin()+itmp);
			
			status=1;//运行状态修改为：运行中
			P[id].selected(now);//打印日志 
		}else{
			now++;
			if(mp.find(now)!=mp.end()){//有进程创建
				wait.push_back(mp[now]);//放入wait队列
			}
			continue;
		}
	}
}

4.3运行结果

5高相应比优先算法

5.1代码实现

void HRRN(){
	long now=8*60;//定义初始时间
	const long end=12*60;//定义终止时间 
	
	long id;//运行进程的ID
	vector<int> wait;//等待队列
	bool status=0;//运行进程的状态(0:结束)
	
	if(mp.find(now)!=mp.end()){//有进程创建 
		wait.push_back(mp[now]);//放入wait队列 
	}
	while(now<end){
		if(status){//进程尚未运行结束 
			P[id].run(now); 
			now++;
			if(mp.find(now)!=mp.end()){//有进程创建
				wait.push_back(mp[now]);//放入wait队列
			}
			if(P[id].runtime==P[id].usedtime){//运行结束 
				P[id].end=now;
				status=0;//运行状态修改为：运行结束 
			}
			continue;
		}
		if(wait.size()!=0){
			
			//找到高响应比的进程
			double surplus=0;
			int itmp;
			for(int i=0;i<wait.size();i++){
				double s=1+((now-P[ wait[i] ].start)-P[ wait[i] ].usedtime)*1.0/P[ wait[i] ].runtime;//相应比=1+等待时间/要求服务时间 
				if(s>surplus){
					surplus=s;
					itmp=i;
				}
			}
			id=wait[itmp];
			wait.erase(wait.begin()+itmp);
			
			status=1;//运行状态修改为：运行中
			P[id].selected(now);//打印日志 
		}else{
			now++;
			if(mp.find(now)!=mp.end()){//有进程创建
				wait.push_back(mp[now]);//放入wait队列
			}
			continue;
		}
	}
}

 5.2运行结果

6.轮转算法

6.1流程

轮转算法是在FCFS的基础上加上了时间片的限制

 6.2代码实现

//RR算法 
void RR(){
	long now=8*60;//定义初始时间 08:00
	const long end=12*60;//定义终止时间 12:00
	const long dt=10;//时间片长度
	
	queue<int> wait;//等待队列
	long id;//运行进程的ID 
	 
	if(mp.find(now)!=mp.end()){//有进程创建 
		long id=mp[now];
		wait.push(id);//放入wait队列 
	}
	while(now<end){
		if(wait.size()==0){//等待队列为空 
			//cout<<"jump"<<endl;
			now++;
			if(mp.find(now)!=mp.end()){//有进程创建 
				wait.push(mp[now]);//放入wait队列
			}
			continue;
		}
			
		id=wait.front();//选出先来的(队头) 
		wait.pop();
		P[id].selected(now); 
		for(long i=0;i<dt;i++){
			P[id].run(now++);
			if(mp.find(now)!=mp.end()){//有进程创建 
				wait.push(mp[now]);//放入wait队列
			}
			if(P[id].runtime!=P[id].usedtime){//运行未结束 
				//wait.push(id);
			}else{//运行结束 
				P[id].end=now;
				break;	
			}
		}
		if(P[id].runtime!=P[id].usedtime){//运行未结束 
			wait.push(id);
		}
	}
}

6.3运行结果

7.抢占式SJF

7.1流程

7.2代码实现

//SJF算法(抢占式)
void SJF2(){
	long now=8*60;//定义初始时间
	const long end=12*60;//定义终止时间 
	
	long id;//运行进程的ID
	vector<int> wait;//等待队列
	bool status=0;//运行进程的状态(0:结束)
	
	if(mp.find(now)!=mp.end()){//有进程创建 
		wait.push_back(mp[now]);//放入wait队列 
	}
	while(now<end){
		if(status){//进程尚未运行结束 
			P[id].run(now); 
			now++;
			if(mp.find(now)!=mp.end()){//有进程创建
				wait.push_back(mp[now]);//放入wait队列
				status=0;//当前进程终止运行 
				if(P[id].runtime!=P[id].usedtime)
					wait.push_back(id);//当前进程放入wait队列
			}
			if(P[id].runtime==P[id].usedtime){//运行结束 
				P[id].end=now;
				status=0;//运行状态修改为：运行结束 
			}
			continue;
		}
		if(wait.size()!=0){
			//找到最短的进程 
			long surplus=(1<<16);
			int itmp;
			for(int i=0;i<wait.size();i++){
				long s=P[ wait[i] ].runtime-P[ wait[i] ].usedtime;
				if(s<surplus){
					surplus=s;
					itmp=i;
				}
			}
			id=wait[itmp];
			wait.erase(wait.begin()+itmp);
			
			status=1;//运行状态修改为：运行中
			P[id].selected(now);//打印日志 
		}else{
			now++;
			if(mp.find(now)!=mp.end()){//有进程创建
				wait.push_back(mp[now]);//放入wait队列
			}
			continue;
		}
	}
}

 7.3运行结果

8.数据打印方法

//数据统计
void cacu_data(int n){
	double sumt1=0;
	double sumt2=0;
	printf("---------------------------------------------------\n"); 
	printf("%2s|%8s|%8s|%8s|%8s|%12s\n","ID","到达时间","运行时间",
			"完成时间","周转时间","带权周转时间");
	for(int i=1;i<=n;i++){
		printf("%-2d|(%02d:%02d) |%-4d min|(%02d:%02d) |%-4d min|%-4lf\n",P[i].id,
			P[i].start/60,P[i].start%60,P[i].runtime,P[i].end/60,P[i].end%60,
			P[i].end-P[i].start,(P[i].end-P[i].start)*1.0/P[i].runtime);
		
		sumt1+=P[i].end-P[i].start;
		sumt2+=(P[i].end-P[i].start)*1.0/P[i].runtime;
	}
	cout<<"平均周转时间:"<<sumt1/n<<endl;
	cout<<"平均带权周转时间:"<<sumt2/n<<endl;
}

9.完整代码

#include<iostream>
#include<stdio.h>
#include<queue>
#include<vector>
#include<cstring>
#include<map>
using namespace std;

//PCB数据结构 
struct PCB{
	long id;
	int priority=1;
	long start;
	long runtime; 
	long usedtime; 
	long end; 
	void create(long i,long st,long rt){
		id=i;
		start=st;
		runtime=rt;
	}
	void selected(long now){
		printf("(%02d:%02d) select process %d,need:%-3d,used:%-3d\n",now/60,now%60,id,runtime,usedtime);
	}
	void run(long now){
		//printf("(%02d:%02d) process %d run,need:%-3d,used:%-3d++\n",now/60,now%60,id,runtime,usedtime);
		usedtime++;
	}
}P[10010];
map<long,long> mp;
//构建测试用例
void initPCS(){
	//默认
	long start[6]={0,8*60,8*60+20,8*60+25,8*60+30,8*60+35};
	long runtimes[6]={0,25,10,20,20,15};
	memset(P,0,5*sizeof(PCB)); 
	for(long id=1;id<=5;id++){
		P[id].create(id,start[id],runtimes[id]);
		mp[ start[id] ]=id;
	}
}
//FCFS算法
void FCFS(){
	long now=8*60;//定义初始时间 08:00
	const long end=12*60;//定义终止时间 12:00
	
	queue<int> wait;//等待队列
	long id;//运行进程的ID
	bool status=0;//运行进程的状态(0:结束)
	
	if(mp.find(now)!=mp.end()){//有进程创建 
		long id=mp[now];
		wait.push(id);//放入wait队列 
	}
	while(now<end){
		if(status){//进程尚未运行结束 
			P[id].run(now); 
			now++;
			if(mp.find(now)!=mp.end()){//有进程创建
				wait.push(mp[now]);//放入wait队列
			}
			if(P[id].runtime==P[id].usedtime){//运行结束 
				P[id].end=now;
				status=0;//运行状态修改为：运行结束 
			}
			continue;
		}
		if(wait.size()!=0){
			id=wait.front();//选出先来的(队头)
			wait.pop();
			status=1;//运行状态修改为：运行中
			P[id].selected(now);//打印日志 
		}else{
			now++;
			if(mp.find(now)!=mp.end()){//有进程创建
				wait.push(mp[now]);//放入wait队列
			}
			continue;
		}
	}
}
//SJF算法(非抢占式)
void SJF(){
	long now=8*60;//定义初始时间
	const long end=12*60;//定义终止时间 
	
	long id;//运行进程的ID 
	vector<int> wait;//等待队列
	bool status=0;//运行进程的状态(0:结束)
	
	if(mp.find(now)!=mp.end()){//有进程创建 
		wait.push_back(mp[now]);//放入wait队列 
	}
	while(now<end){
		if(status){//进程尚未运行结束 
			P[id].run(now); 
			now++;
			if(mp.find(now)!=mp.end()){//有进程创建
				wait.push_back(mp[now]);//放入wait队列
			}
			if(P[id].runtime==P[id].usedtime){//运行结束 
				P[id].end=now;
				status=0;//运行状态修改为：运行结束 
			}
			continue;
		}
		if(wait.size()!=0){
			
			//找到最短的进程 
			long surplus=(1<<16);
			int itmp;
			for(int i=0;i<wait.size();i++){
				long s=P[ wait[i] ].runtime;
				if(s<surplus){
					surplus=s;
					itmp=i;
				}
			}
			id=wait[itmp];
			wait.erase(wait.begin()+itmp);
			
			status=1;//运行状态修改为：运行中
			P[id].selected(now);//打印日志 
		}else{
			now++;
			if(mp.find(now)!=mp.end()){//有进程创建
				wait.push_back(mp[now]);//放入wait队列
			}
			continue;
		}
	}
}
//SJF算法(抢占式)
void SJF2(){
	long now=8*60;//定义初始时间
	const long end=12*60;//定义终止时间 
	
	long id;//运行进程的ID
	vector<int> wait;//等待队列
	bool status=0;//运行进程的状态(0:结束)
	
	if(mp.find(now)!=mp.end()){//有进程创建 
		wait.push_back(mp[now]);//放入wait队列 
	}
	while(now<end){
		if(status){//进程尚未运行结束 
			P[id].run(now); 
			now++;
			if(mp.find(now)!=mp.end()){//有进程创建
				wait.push_back(mp[now]);//放入wait队列
				status=0;//当前进程终止运行 
				if(P[id].runtime!=P[id].usedtime)
					wait.push_back(id);//当前进程放入wait队列
			}
			if(P[id].runtime==P[id].usedtime){//运行结束 
				P[id].end=now;
				status=0;//运行状态修改为：运行结束 
			}
			continue;
		}
		if(wait.size()!=0){
			//找到最短的进程 
			long surplus=(1<<16);
			int itmp;
			for(int i=0;i<wait.size();i++){
				long s=P[ wait[i] ].runtime-P[ wait[i] ].usedtime;
				if(s<surplus){
					surplus=s;
					itmp=i;
				}
			}
			id=wait[itmp];
			wait.erase(wait.begin()+itmp);
			
			status=1;//运行状态修改为：运行中
			P[id].selected(now);//打印日志 
		}else{
			now++;
			if(mp.find(now)!=mp.end()){//有进程创建
				wait.push_back(mp[now]);//放入wait队列
			}
			continue;
		}
	}
}
void HRRN(){
	long now=8*60;//定义初始时间
	const long end=12*60;//定义终止时间 
	
	long id;//运行进程的ID
	vector<int> wait;//等待队列
	bool status=0;//运行进程的状态(0:结束)
	
	if(mp.find(now)!=mp.end()){//有进程创建 
		wait.push_back(mp[now]);//放入wait队列 
	}
	while(now<end){
		if(status){//进程尚未运行结束 
			P[id].run(now); 
			now++;
			if(mp.find(now)!=mp.end()){//有进程创建
				wait.push_back(mp[now]);//放入wait队列
			}
			if(P[id].runtime==P[id].usedtime){//运行结束 
				P[id].end=now;
				status=0;//运行状态修改为：运行结束 
			}
			continue;
		}
		if(wait.size()!=0){
			
			//找到高响应比的进程
			double surplus=0;
			int itmp;
			for(int i=0;i<wait.size();i++){
				double s=1+((now-P[ wait[i] ].start)-P[ wait[i] ].usedtime)*1.0/P[ wait[i] ].runtime;//相应比=1+等待时间/要求服务时间 
				if(s>surplus){
					surplus=s;
					itmp=i;
				}
			}
			id=wait[itmp];
			wait.erase(wait.begin()+itmp);
			
			status=1;//运行状态修改为：运行中
			P[id].selected(now);//打印日志 
		}else{
			now++;
			if(mp.find(now)!=mp.end()){//有进程创建
				wait.push_back(mp[now]);//放入wait队列
			}
			continue;
		}
	}
} 
//RR算法 
void RR(){
	long now=8*60;//定义初始时间 08:00
	const long end=12*60;//定义终止时间 12:00
	const long dt=10;//时间片长度
	
	queue<int> wait;//等待队列
	long id;//运行进程的ID 
	 
	if(mp.find(now)!=mp.end()){//有进程创建 
		long id=mp[now];
		wait.push(id);//放入wait队列 
	}
	while(now<end){
		if(wait.size()==0){//等待队列为空 
			//cout<<"jump"<<endl;
			now++;
			if(mp.find(now)!=mp.end()){//有进程创建 
				wait.push(mp[now]);//放入wait队列
			}
			continue;
		}
			
		id=wait.front();//选出先来的(队头) 
		wait.pop();
		P[id].selected(now); 
		for(long i=0;i<dt;i++){
			P[id].run(now++);
			if(mp.find(now)!=mp.end()){//有进程创建 
				wait.push(mp[now]);//放入wait队列
			}
			if(P[id].runtime!=P[id].usedtime){//运行未结束 
				//wait.push(id);
			}else{//运行结束 
				P[id].end=now;
				break;	
			}
		}
		if(P[id].runtime!=P[id].usedtime){//运行未结束 
			wait.push(id);
		}
	}
}
//数据统计
void cacu_data(int n){
	cout<<endl<<"------初始数据------"<<endl;
	printf("%-2s|%-8s|%-8s\n","ID","到达时间","运行时间");
	for(int i=1;i<=n;i++){
		printf("%-2d|(%02d:%02d) |%-4d min\n",
		P[i].id,
			P[i].start/60,P[i].start%60,P[i].runtime); 
	}
	double sumt1=0;
	double sumt2=0;
	printf("\n----------结果统计---------------------------------\n"); 
	printf("%2s|%8s|%8s|%8s|%8s|%12s\n","ID","到达时间","运行时间",
			"完成时间","周转时间","带权周转时间");
	for(int i=1;i<=n;i++){
		printf("%-2d|(%02d:%02d) |%-4d min|(%02d:%02d) |%-4d min|%-4lf\n",P[i].id,
			P[i].start/60,P[i].start%60,P[i].runtime,P[i].end/60,P[i].end%60,
			P[i].end-P[i].start,(P[i].end-P[i].start)*1.0/P[i].runtime);
		
		sumt1+=P[i].end-P[i].start;
		sumt2+=(P[i].end-P[i].start)*1.0/P[i].runtime;
	}
	cout<<"平均周转时间:"<<sumt1/n<<endl;
	cout<<"平均带权周转时间:"<<sumt2/n<<endl;
}
//主函数 
int main(){
	initPCS();
	//FCFS();//先来先服务 
	//SJF();//短作业优先 
	//SJF2();//抢占式短作业优先 
	//HRRN();//高相应比优先 
	RR();//轮转(时间片默认10分钟)
	
	cacu_data(5);//统计
	return 0;
}

li345376
关注
  • 6
    点赞
  • 踩
  • 58
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
操作系统进程调度算法
01-13
先来先服务，短进程优先，高响应比，时间片轮转算法
操作系统进程调度C++代码实现
05-25
目的: 在进程控制、请求分页存储器管理、设备管理基础上 实现按先来先服务 FCFS 、短作业优先 SJF 以及时间片 轮转算法调度进程的模拟过程 。 内容 1.在第 1 3 部分基础上扩展； 2.支持 FCFS 、短 作业优先以及时间片调度算法。 3.能够较方便地查看调度过程及平均周转时间、平均带权周转时 间。 4.支持优先权调度算法与其它算法相结合的调度模式。 5.调度时应适当输出调度过程中各进程状态队列的变化情况以及进程的已执行时 间、还需服务时间（针对时间片轮转算法）。 6.完成银行家算法的实现。
C++实现进程调度算法（FCFS&RR&优先级调度&SJF）
最新发布
学习者的博客
05-12 848
文章根据已给条件（实验课老师给的）对进程调度算法进行分析，应用范围有限，但可以初步了解进程调度算法，由于本人学识浅薄，文章中难免有不足和错误之处，恳请读者批评指正。
操作系统实验一模拟优先级调度算法（C语言实现附带详细注释）_c语言程序编程模拟三个用户进程,它们的优先级从高到低分别为 p1,p2,p3,它们需要打(2)
2401_84181606的博客
05-07 724
优先级调度算法既可以用于作业调度，又可以用于进程调度。该算法中的优先级用于描述作业或者进程的紧迫程度，主要思想是每次选取优先级最高的进程或者作业，将资源或者处理机分配给它使用。
操作系统实验--进程调度算法的模拟代码
m0_62600503的博客
11-07 292
代码如下，运行了没问题！
操作系统代码实验（进程调度算法）
qq_59675202的博客
11-12 205
(algo == 'r'llalgo =='R))//这个对RR不适应!if(run->needtine < run->round)// 当剩余时间小于时间片轮转时间时的情况。if(run->needtime == 0){// 当run结束时放入finish队列里。if(flag){//执行完如果不是剩一一个的话，就把run放到队尾。//当ready列里只有 -个时做标记。//run每次运行ready的队头。//当ready剩-个时做标记。if(i == 1)/*按顺序插入到ready链表中*/
操作系统课程设计，三种作业调度算法实现（含代码）
QiaoLiu___lq的博客
12-04 1721
操作系统课程设计，三种作业调度算法实现（含代码），短作业优先算法、先来先服务算法、小作业优先算法
【操作系统】使用C/C++实现进程调度算法
Otto的学习笔记
11-19 3426
使用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<co
操作系统自学笔记代码篇——磁盘调度算法之FCFS
Maolianwika的博客
07-02 178
【代码】操作系统自学笔记代码篇——磁盘调度算法之FCFS。
操作系统处理器调度算法C++程序.doc
11-15
操作系统处理器调度算法C++程序 操作系统处理器调度算法是操作系统中的一种重要算法，它决定了作业的执行顺序和资源分配方式。常见的处理器调度算法有先来先服务算法、最短作业优先算法、时间片轮转算法、多级反馈...
操作系统短作业优先进程调度算法
05-29
短作业优先进程调度算法 （1）用C语言（或其它语言，如Java）实现对N个进程采用某种进程调度算法（如动态优先权调度）的调度。 （2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：  进程标识数ID。  进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。  进程已占用CPU时间CPUTIME。  进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。  进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。  进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。  进程状态STATE。  队列指针NEXT，用来将PCB排成队列。 （3）优先数改变的原则：  进程在就绪队列中呆一个时间片，优先数增加1。  进程每运行一个时间片，优先数减3。 （4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。 （5）分析程序运行的结果，谈一下自己的认识。
进程调度的设计与实现
06-17
进程调度的设计与实现，linux下Qt实现的，用表格的形式展现了进程调度的过程，横轴是优先级，竖轴是优先级队列（最多50个），数字是进程标识符，括号内是生命周期。
处理机调度算法 C++代码
11-21
模拟操作系统的处理机调度算法实现进程和处理机的管理
操作系统-进程调度算法.zip
12-25
操作系统进程调度算法 先进先出FIFO、最高优先级HPF（非抢占式）、时间片轮转算法RR 输入：进程序列文件，其中存储的是一系列要执行的进程， 每个进程包括 四个数据项： 进程id 号、 进程状态(1 就绪 2 等待 3 运行)...
操作系统课程设计大作业C++进程调度算法的模拟实现源码.zip
06-17
操作系统课程设计大作业C++进程调度算法的模拟实现源码，实现了 动态优先级、先来先服务、时间片轮转 三个算法 安装教程 下载到本地，然后直接用VS打开运行即可 操作系统课程设计大作业C++进程调度算法的模拟实现...
进程调度算法c语言代码简单,进程调度--动态优先数法（C语言实现）
weixin_36474001的博客
05-22 881
该楼层疑似违规已被系统折叠隐藏此楼查看此楼ready=s;}}//优先数创建初始PCB信息void create1(char alg){PCB *p;int i,time;char na[10];ready=NULL; //就绪队列头文件finish=NULL; ...
最短作业优先调度算法（SJF算法）的C++实现
热门推荐
EbowTang的练习场
08-29 1万+
题目要求： 在作业调度中，该算法每次从后备作业队列中挑选估计服务时间最短的一个或几个作业，将他们调入内存，分配必要的资源，创建进程并放入就绪队列。与在进程调度中的原理类似。假设有n项作业位于就绪队列中，这些作业的提交时间用数组requestTimes按照提交时间的先后顺序存储，对应的作业服务时间（持续时间）用数组durations存储。采用SJF算法，计算n项作业的平均等待时间。当存在多个相同长
进程调度算法C++
05-26
进程调度算法是操作系统中非常重要的一部分，用于决定哪些进程将被调度执行。常见的进程调度算法有以下几种： 1. 先来先服务（FCFS）调度算法：按照进程到达的先后顺序进行调度，先到达的进程先执行，后到达的进程后执行。 2. 最短作业优先（SJF）调度算法：按照进程的执行时间进行排序，执行时间短的进程先执行。 3. 优先级调度算法：为每个进程分配一个优先级，根据优先级高低进行调度。 4. 时间片轮转（RR）调度算法：将 CPU 时间分成多个时间片，每个进程执行一个时间片，时间片用完后将进程放到队列尾部，继续执行下一个进程。 下面是一个基于 FCFS 调度算法的 C++ 代码示例： ```c++ #include <iostream> #include <queue> using namespace std; struct Process { int pid; // 进程 ID int arrive; // 到达时间 int burst; // 执行时间 }; bool operator<(const Process &p1, const Process &p2) { return p1.arrive > p2.arrive; // 按到达时间从小到大排序 } int main() { priority_queue<Process> q; // 优先队列，用于按到达时间排序 int n; // 进程数 cin >> n; for (int i = 0; i < n; i++) { Process p; cin >> p.pid >> p.arrive >> p.burst; q.push(p); } int time = 0; // 当前时间 while (!q.empty()) { Process p = q.top(); q.pop(); time = max(time, p.arrive); // 更新时间，确保当前时间不小于进程的到达时间 time += p.burst; // 执行进程 cout << p.pid << " " << time << endl; // 输出进程 ID 和完成时间 } return 0; } ```
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

li345376

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值